diff --git a/.Attic/metta_lang/corelib.metta.buffer~ b/.Attic/metta_lang/corelib.metta.buffer~ deleted file mode 100644 index 8be25976c1..0000000000 --- a/.Attic/metta_lang/corelib.metta.buffer~ +++ /dev/null @@ -1,8 +0,0 @@ -afn_stem_filename('/home/deb12user/metta-wam/.Attic/metta_lang/corelib.metta','/home/deb12user/metta-wam/.Attic/metta_lang/corelib.metta','/home/deb12user/metta-wam/.Attic/metta_lang/corelib.metta'). -:-multifile user:afn_stem_filename/3. -:-dynamic user:metta_file_buffer/7. -:-multifile user:metta_file_buffer/7. -user:metta_file_buffer(1,1000001,constant,'import!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/corelib.metta',range(line_char(0,2),line_char(0,9))). -user:metta_file_buffer(1,1000001,constant,'stdlib_mettalog.metta',[],'/home/deb12user/metta-wam/.Attic/metta_lang/corelib.metta',range(line_char(0,10),line_char(0,31))). -user:metta_file_buffer(0,1000001,decl(import),exec(['import!','stdlib_mettalog.metta']),[],'/home/deb12user/metta-wam/.Attic/metta_lang/corelib.metta',range(line_char(0,0),line_char(0,32))). -user:metta_file_buffer(0,2000001,constant,end_of_file,[],'/home/deb12user/metta-wam/.Attic/metta_lang/corelib.metta',range(line_char(1,0),line_char(1,0))). diff --git a/.Attic/metta_lang/metta_interp.pl.bak b/.Attic/metta_lang/metta_interp.pl.bak deleted file mode 100644 index 6c801ce39c..0000000000 --- a/.Attic/metta_lang/metta_interp.pl.bak +++ /dev/null @@ -1,2369 +0,0 @@ -/* - * Project: MeTTaLog - A MeTTa to Prolog Transpiler/Interpreter - * Description: This file is part of the source code for a transpiler designed to convert - * MeTTa language programs into Prolog, utilizing the SWI-Prolog compiler for - * optimizing and transforming function/logic programs. It handles different - * logical constructs and performs conversions between functions and predicates. - * - * Author: Douglas R. Miles - * Contact: logicmoo@gmail.com / dmiles@logicmoo.org - * License: LGPL - * Repository: https://github.com/trueagi-io/metta-wam - * https://github.com/logicmoo/hyperon-wam - * Created Date: 8/23/2023 - * Last Modified: $LastChangedDate$ # You will replace this with Git automation - * - * Usage: This file is a part of the transpiler that transforms MeTTa programs into Prolog. For details - * on how to contribute or use this project, please refer to the repository README or the project documentation. - * - * Contribution: Contributions are welcome! For contributing guidelines, please check the CONTRIBUTING.md - * file in the repository. - * - * Notes: - * - Ensure you have SWI-Prolog installed and properly configured to use this transpiler. - * - This project is under active development, and we welcome feedback and contributions. - * - * Acknowledgments: Special thanks to all contributors and the open source community for their support and contributions. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the - * distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ -% Set the encoding for the Prolog system to UTF-8 to ensure proper handling of characters. -% The previously commented out line was for iso_latin_1 encoding. -% UTF-8 is more universal and can handle a wider range of characters. -:- encoding(utf8). - -% Set the 'RUST_BACKTRACE' environment variable to 'full'. -% This likely enables detailed error backtraces when using Rust-based components. -% Rust will now output full stack traces when errors occur, which aids in debugging. -:- setenv('RUST_BACKTRACE', full). - -% Set the Prolog flag for encoding to UTF-8 (overrides other default encodings). -% This ensures that the Prolog interpreter treats all input/output as UTF-8 encoded. -:- set_prolog_flag(encoding, utf8). - -% Set a global non-backtrackable variable 'cmt_override' with a specific string pattern. -% This could be used for customizing the way comments or other formatting behaviors are handled. -:- nb_setval(cmt_override, lse('; ', ' !(" ', ' ") ')). - -% Set the flag to make the source search relative to the working directory. -% This helps locate Prolog files from the current working directory. -:- set_prolog_flag(source_search_working_directory, true). - -% Enable backtracing, which allows tracking the sequence of goals that led to an error. -% This is useful for debugging as it shows the call stack at the time of an error. -:- set_prolog_flag(backtrace, true). - -% Set the maximum depth for the backtrace to 100, meaning up to 100 frames of the call stack will be shown. -:- set_prolog_flag(backtrace_depth, 100). - -% Set the maximum goal depth for backtraces, limiting the display of deeply nested goal calls. -:- set_prolog_flag(backtrace_goal_dept, 100). - -% Enable showing line numbers in the backtrace, which can help pinpoint where in the source code an error occurred. -:- set_prolog_flag(backtrace_show_lines, true). - -% Configure the flag to customize how Prolog writes out attributes (such as variables and terms). -% Using 'portray' ensures that the output is human-readable and properly formatted. -:- set_prolog_flag(write_attributes, portray). - -% Enable debugging on errors. -% When an error occurs, this setting will automatically start the Prolog debugger, providing detailed information about the error. -:- set_prolog_flag(debug_on_error, true). - -% !(set-prolog-flag debug-on-error True) - -% Load additional Prolog support functions from the 'swi_support' file. -% This could include helper predicates or extensions for SWI-Prolog. -:- ensure_loaded(swi_support). - -% Load the Prolog documentation library (pldoc). -% This library provides tools for generating and interacting with Prolog documentation. -:- ensure_loaded(library(pldoc)). - - - -/* -% Set the encoding of the `current_input` stream to UTF-8. -% This ensures that any input read from `current_input` (which is typically `user_input`) is interpreted as UTF-8. -:- set_stream(current_input, encoding(utf8)). - -% Set the encoding for the `user_input` stream to UTF-8. -% This makes sure that all input read from `user_input` is correctly handled as UTF-8 encoded text. -:- set_stream(user_input, encoding(utf8)). - -% Treat `user_output` as a terminal (TTY). -% This ensures that output to the terminal behaves properly, recognizing that it's interacting with a terminal (e.g., for handling special characters). -:- set_stream(user_output, tty(true)). - -% Set the encoding for the `user_output` stream to UTF-8. -% This ensures that all output sent to `user_output` is encoded in UTF-8, allowing the display of Unicode characters. -:- set_stream(user_output, encoding(utf8)). - -% Treat `user_error` as a terminal (TTY). -% This ensures that error messages are handled as terminal output, allowing for proper interaction when the user sees error messages. -:- set_stream(user_error, tty(true)). - -% Set the encoding for the `user_error` stream to UTF-8. -% This ensures that error messages and other output sent to `user_error` are encoded in UTF-8, preventing issues with special characters in error messages. -:- set_stream(user_error, encoding(utf8)). - -% Flush any pending output to ensure that anything waiting to be written to output is immediately written. -% Useful to make sure output is synchronized and nothing is left in the buffer. -:- flush_output. -*/ -%:- set_prolog_flag(debug_on_interrupt,true). -%:- set_prolog_flag(compile_meta_arguments,control). -:- (prolog_load_context(directory, Value);Value='.'), absolute_file_name('../../packs/',Dir,[relative_to(Value)]), - atom_concat(Dir,'predicate_streams',PS), - atom_concat(Dir,'logicmoo_utils',LU), - attach_packs(Dir,[duplicate(replace),search(first)]), - pack_attach(PS,[duplicate(replace),search(first)]), - pack_attach(LU,[duplicate(replace),search(first)]). -% :- attach_packs. -%:- ensure_loaded(metta_interp). -is_win64:- current_prolog_flag(windows,_). -is_win64_ui:- is_win64,current_prolog_flag(hwnd,_). - -dont_change_streams:- true. - -%! lazy_load_python is det. -% -% This predicate represents a placeholder or a stub for lazily loading the Python -% integration. Currently, it does not contain any implementation logic. -% Presumably, it would attempt to load Python-related resources or interfaces -% when needed, avoiding unnecessary overhead if Python is not required. -% -% The implementation should be added to perform the actual lazy loading of -% the Python environment or integration. -% -:- dynamic(lazy_load_python/0). -lazy_load_python. - -:- dynamic(user:is_metta_src_dir/1). -:- prolog_load_context(directory,Dir), - retractall(user:is_metta_src_dir(_)), - asserta(user:is_metta_src_dir(Dir)). - -metta_root_dir(Dir):- is_metta_src_dir(Value), absolute_file_name('../../',Dir,[relative_to(Value)]). -metta_root_dir(Dir):- getenv('METTA_DIR',Dir),!. - -metta_library_dir(Dir):- metta_root_dir(Value), absolute_file_name('./library/',Dir,[relative_to(Value)]). - -metta_dir(Dir):- metta_library_dir(Value), absolute_file_name('./genome/',Dir,[relative_to(Value)]). -metta_dir(Dir):- is_metta_src_dir(Dir). -metta_dir(Dir):- metta_library_dir(Dir). -metta_dir(Dir):- metta_root_dir(Dir). -metta_dir(Dir):- is_metta_src_dir(Value), absolute_file_name('../flybase/',Dir,[relative_to(Value)]). - -:- dynamic user:file_search_path/2. -:- multifile user:file_search_path/2. -user:file_search_path(library,Dir):- metta_dir(Dir). -user:file_search_path(mettalog,Dir):- metta_dir(Dir). - - -:- is_win64 -> ensure_loaded(library(logicmoo_utils)) ; true. - -% :- initialization(attach_packs). -:- nodebug(metta(eval)). -:- nodebug(metta(exec)). -:- nodebug(metta(load)). -:- nodebug(metta(prolog)). - -:- dynamic(function_arity/2). -:- dynamic(predicate_arity/2). - - -:-multifile(user:metta_file/3). -:-dynamic(user:metta_file/3). - -:- multifile(reset_cache/0). - - :-multifile(metta_type/3). - :-dynamic(metta_type/3). - - :-multifile(metta_defn/3). - :-dynamic(metta_defn/3). - - -:-multifile(user:asserted_metta_pred/2). -:-dynamic(user:asserted_metta_pred/2). -:-multifile(user:loaded_into_kb/2). -:-dynamic(user:loaded_into_kb/2). -:- dynamic(user:is_metta_dir/1). -:- multifile(metta_compiled_predicate/3). -:- dynamic(metta_compiled_predicate/3). - - -once_writeq_nl(_):- \+ clause(pfcTraceExecution,true),!. -once_writeq_nl(P):- nb_current('$once_writeq_ln',W),W=@=P,!. -once_writeq_nl(P):- - \+ \+ (numbervars(P,444,_,[attvar(skip),singletons(true)]), - ansi_format([fg(cyan)],'~N~q.~n',[P])),nb_setval('$once_writeq_ln',P),!. -% TODO uncomment this next line but it is breaking the curried chainer -% pfcAdd_Now(P):- pfcAdd(P),!. -pfcAdd_Now(P):- current_predicate(pfcAdd/1),!, once_writeq_nl(pfcAdd(P)),pfcAdd(P). -pfcAdd_Now(P):- once_writeq_nl(asssert(P)),assert(P). -%:- endif. - -system:copy_term_g(I,O):- ground(I),!,I=O. -system:copy_term_g(I,O):- copy_term(I,O). - -:- ensure_loaded(metta_debug). - -is_metta_flag(What):- notrace(is_flag0(What)). - -true_flag. -false_flag:- fail. - -is_tRuE(TF):- TF=='True',!. -is_tRuE(TF):- TF=='true',!. -is_flag0(What):- nb_current(What,TF),TF\==[],!,is_tRuE(TF). -is_flag0(What):- current_prolog_flag(What,TF),TF\==[],!,is_tRuE(TF). -is_flag0(What):- - symbol_concat('--',What,FWhat),symbol_concat(FWhat,'=true',FWhatTrue), - symbol_concat('--no-',What,NoWhat),symbol_concat(FWhat,'=false',FWhatFalse), - is_flag0(What,[FWhat,FWhatTrue],[NoWhat,FWhatFalse]). - -is_flag0(What,_FWhatTrue,FWhatFalse):- - current_prolog_flag(os_argv,ArgV), - member(FWhat,FWhatFalse),member(FWhat,ArgV),!, - notrace(catch(set_prolog_flag(What,false),_,true)), - set_option_value(What,'False'),!,fail. -is_flag0(What,FWhatTrue,_FWhatFalse):- - current_prolog_flag(os_argv,ArgV), - member(FWhat,FWhatTrue),member(FWhat,ArgV),!, - notrace(catch(set_prolog_flag(What,true),_,true)), - set_option_value(What,'True'),!. -is_flag0(What,_FWhatTrue,_FWhatFalse):- - current_prolog_flag(os_argv,ArgV), - symbolic_list_concat(['--',What,'='],Starts), - member(FWhat,ArgV),symbol_concat(Starts,Rest,FWhat), - set_option_value_interp(What,Rest),!. - -is_compiling:- current_prolog_flag(os_argv,ArgV),member(E,ArgV), (E==qcompile_mettalog;E==qsave_program),!. -is_compiled:- current_prolog_flag(os_argv,ArgV), member('-x',ArgV),!. -is_compiled:- current_prolog_flag(os_argv,ArgV),\+ member('swipl',ArgV),!. - -is_converting:- is_metta_flag('convert'). - -is_compat:- is_metta_flag('compat'). - -is_mettalog:- is_win64,!. -is_mettalog:- is_metta_flag('log'). - -is_synthing_unit_tests:- notrace(is_synthing_unit_tests0). -is_synthing_unit_tests0:- is_testing. -%is_synthing_unit_tests0:- is_html. -% is_synthing_unit_tests0:- is_compatio,!,fail. - -is_testing:- is_metta_flag('test'). -is_html:- is_metta_flag('html'). - -:- ensure_loaded(metta_printer). -:- ensure_loaded(metta_loader). - - -:- nodebug(metta('trace-on-eval')). - -is_compatio:- notrace(is_compatio0). -is_compatio0:- is_win64,!,fail. -is_compatio0:- is_testing,!,fail. -is_compatio0:- is_flag0('compatio'). -is_compatio0:- is_mettalog,!,fail. -%is_compatio0:- is_html,!,fail. -is_compatio0:- !. - -keep_output:- !. -keep_output:- dont_change_streams,!. -keep_output:- is_win64,!. -keep_output:- is_mettalog,!. -keep_output:- is_testing,!. - -keep_output:- is_compatio,!,fail. - - -:- volatile(original_user_output/1). -:- dynamic(original_user_output/1). -original_user_output(X):- stream_property(X,file_no(1)). -original_user_error(X):- stream_property(X,file_no(2)). -:- original_user_output(_)->true;(current_output(Out),asserta(original_user_output(Out))). -unnullify_output:- current_output(MFS), original_user_output(OUT), MFS==OUT, !. -unnullify_output:- original_user_output(MFS), set_prolog_IO(user_input,MFS,user_error). - -null_output(MFS):- dont_change_streams,!, original_user_output(MFS),!. -null_output(MFS):- use_module(library(memfile)), - new_memory_file(MF),open_memory_file(MF,append,MFS). -:- volatile(null_user_output/1). -:- dynamic(null_user_output/1). -:- null_user_output(_)->true;(null_output(MFS), - asserta(null_user_output(MFS))). - - -nullify_output:- keep_output,!. -nullify_output:- dont_change_streams,!. -nullify_output:- nullify_output_really. -nullify_output_really:- current_output(MFS), null_user_output(OUT), MFS==OUT, !. -nullify_output_really:- null_user_output(MFS), set_prolog_IO(user_input,MFS,MFS). - -set_output_stream :- dont_change_streams,!. -set_output_stream :- \+ keep_output -> nullify_output; unnullify_output. -:- set_output_stream. -% :- nullify_output. - -switch_to_mettalog:- - unnullify_output, - set_option_value('compatio',false), - set_option_value('compat',false), - set_option_value('load',show), - set_option_value('load',verbose), - set_option_value('log',true), - %set_option_value('test',true), - forall(mettalog_option_value_def(Name, DefaultValue),set_option_value(Name, DefaultValue)), - set_output_stream. - -switch_to_mettarust:- - nullify_output, - set_option_value('compatio',true), - set_option_value('compat',true), - set_option_value('log',false), - set_option_value('test',false), - forall(rust_option_value_def(Name, DefaultValue),set_option_value(Name, DefaultValue)), - set_output_stream. - - - -show_os_argv:- is_compatio,!. -show_os_argv:- current_prolog_flag(os_argv,ArgV),write('; libswipl: '),writeln(ArgV). -is_pyswip:- current_prolog_flag(os_argv,ArgV),member( './',ArgV). -:- multifile(is_metta_data_functor/1). -:- dynamic(is_metta_data_functor/1). -:- multifile(is_nb_space/1). -:- dynamic(is_nb_space/1). -%:- '$set_source_module'('user'). -:- use_module(library(filesex)). -:- use_module(library(system)). -:- use_module(library(shell)). -%:- use_module(library(tabling)). - -:- nb_setval(self_space, '&self'). -current_self(Self):- ((nb_current(self_space,Self),Self\==[])->true;Self='&self'). -:- nb_setval(repl_mode, '+'). - - -% Define the option and call help documentation -option_value_def(Name, DefaultValue) :- - all_option_value_name_default_type_help(Name, DefaultValue, _, _, _). - -rust_option_value_def(Name, DefaultValue) :- - all_option_value_name_default_type_help(Name, MettaLogDV,[DefaultValue|_], _Cmt,_Topic), - MettaLogDV \= DefaultValue. - -mettalog_option_value_def(Name, MettaLogDV) :- - all_option_value_name_default_type_help(Name, MettaLogDV,[DefaultValue|_], _Cmt,_Topic), - MettaLogDV \= DefaultValue. - - -:- discontiguous(option_value_name_default_type_help/5). -:- discontiguous(all_option_value_name_default_type_help/5). - -all_option_value_name_default_type_help(Name, DefaultValue, Type, Cmt, Topic):- - option_value_name_default_type_help(Name, DefaultValue, Type, Cmt, Topic). - -% Compatibility and Modes -option_value_name_default_type_help('compat', false, [true, false], "Enable all compatibility with MeTTa-Rust", 'Compatibility and Modes'). -option_value_name_default_type_help('compatio', false, [true, false], "Enable IO compatibility with MeTTa-Rust", 'Compatibility and Modes'). -option_value_name_default_type_help(src_indents, false, [false,true], "Sets the indenting of list printing", 'Compatibility and Modes'). -all_option_value_name_default_type_help('repl', auto, [false, true, auto], "Enter REPL mode (auto means true unless a file argument was supplied)", 'Execution and Control'). -all_option_value_name_default_type_help('prolog', false, [false, true], "Enable or disable Prolog REPL mode", 'Compatibility and Modes'). -option_value_name_default_type_help('devel', false, [false, true], "Developer mode", 'Compatibility and Modes'). -all_option_value_name_default_type_help('exec', noskip, [noskip, skip], "Controls execution during script loading: noskip or skip (don't-skip-include/binds) vs skip-all", 'Execution and Control'). - -% Resource Limits -option_value_name_default_type_help('stack-max', 500, [inf,1000,10_000], "Maximum stack depth allowed during execution", 'Resource Limits'). -all_option_value_name_default_type_help('maximum-result-count', inf, [inf,1,2,3,10], "Set the maximum number of results, infinite by default", 'Miscellaneous'). -option_value_name_default_type_help('limit', inf, [inf,1,2,3,10], "Set the maximum number of results, infinite by default", 'Miscellaneous'). -option_value_name_default_type_help('initial-result-count', 10, [inf,10], "For MeTTaLog log mode: print the first 10 answers without waiting for user", 'Miscellaneous'). - -% Miscellaneous -option_value_name_default_type_help('answer-format', 'show', ['rust', 'silent', 'detailed'], "Control how results are displayed", 'Output and Logging'). -option_value_name_default_type_help('repeats', true, [true, false], "false to avoid repeated results", 'Miscellaneous'). -option_value_name_default_type_help('time', true, [false, true], "Enable or disable timing for operations (in Rust compatibility mode, this is false)", 'Miscellaneous'). - -% Testing and Validation -option_value_name_default_type_help('synth-unit-tests', false, [false, true], "Synthesize unit tests", 'Testing and Validation'). - -% Optimization and Compilation -option_value_name_default_type_help('optimize', true, [true, false], "Enable or disable optimization", 'Optimization and Compilation'). -option_value_name_default_type_help('transpiler', 'silent', ['silent', 'verbose'], "Sets the expected level of output from the transpiler", 'Output and Logging'). -option_value_name_default_type_help('compile', 'false', ['false', 'true', 'full'], "Compilation option: 'true' is safe vs 'full' means to include unsafe as well", 'Optimization and Compilation'). -option_value_name_default_type_help('tabling', auto, [auto, true, false], "When to use predicate tabling (memoization)", 'Optimization and Compilation'). - -% Output and Logging -option_value_name_default_type_help('log', false, [false, true], "Enable or disable logging", 'Output and Logging'). -all_option_value_name_default_type_help('html', false, [false, true], "Generate HTML output", 'Output and Logging'). -all_option_value_name_default_type_help('python', true, [true, false], "Enable Python functions", 'Output and Logging'). -option_value_name_default_type_help('output', './', ['./'], "Set the output directory", 'Output and Logging'). -option_value_name_default_type_help('exeout', './Sav.gitlab.MeTTaLog', [_], "Output executable location", 'Miscellaneous'). -option_value_name_default_type_help('halt', false, [false, true], "Halts execution after the current operation", 'Miscellaneous'). - -% Debugging and Tracing -option_value_name_default_type_help('trace-length', 500, [inf], "Length of the trace buffer for debugging", 'Debugging and Tracing'). -option_value_name_default_type_help('trace-on-overtime', 4.0, [inf], "Trace if execution time exceeds limit", 'Debugging and Tracing'). -option_value_name_default_type_help('trace-on-overflow', 1000, [inf], "Trace on stack overflow", 'Debugging and Tracing'). -option_value_name_default_type_help('trace-on-eval', false, [false, true], "Trace during normal evaluation", 'Debugging and Tracing'). -option_value_name_default_type_help('trace-on-load', silent, [silent, verbose], "Verbosity on file loading", 'Debugging and Tracing'). -option_value_name_default_type_help('trace-on-exec', false, [silent, verbose], "Trace on execution during loading", 'Debugging and Tracing'). -option_value_name_default_type_help('trace-on-error', 'non-type', [false, 'non-type', true], "Trace on all or none or non-type errors", 'Debugging and Tracing'). -option_value_name_default_type_help('trace-on-fail', false, [false, true], "Trace on failure", 'Debugging and Tracing'). -option_value_name_default_type_help('trace-on-test', true, [silent, false, verbose], "Trace on success as well", 'Debugging and Tracing'). -option_value_name_default_type_help('repl-on-error', true, [false, true], "Drop to REPL on error", 'Debugging and Tracing'). -option_value_name_default_type_help('repl-on-fail', false, [false, true], "Start REPL on failed unit test", 'Debugging and Tracing'). -option_value_name_default_type_help('exit-on-fail', false, [true, false], "Rust exits on first Assertion Error", 'Debugging and Tracing'). - -% Define the possible values for various types - -% Verbosity values -type_value(verbosity_mode, 'silent'). % No output or only critical errors -type_value(verbosity_mode, 'error'). % Only errors are shown -type_value(verbosity_mode, 'warn'). % Errors and warnings are shown -type_value(verbosity_mode, 'info'). % General information (default level) -type_value(verbosity_mode, 'debug'). % Detailed debug output -type_value(verbosity_mode, 'trace'). % Extremely detailed output, execution trace - - - -% Compile modes -type_value(compile_mode, 'false'). % Compilation is disabled -type_value(compile_mode, 'true'). % Basic compilation is enabled -type_value(compile_mode, 'auto'). % Automatically decide based on context -type_value(compile_mode, 'full'). % Full compilation is enabled - -% Execution modes -type_value(exec_mode, 'noskip'). % Execution proceeds normally -type_value(exec_mode, 'skip'). % Execution is skipped - -% Fail modes -type_value(fail_mode, 'repl'). % On failure, drop into REPL -type_value(fail_mode, 'exit'). % On failure, exit execution - -% Error handling modes -type_value(error_mode, 'default'). % Default error handling mode -type_value(warning_mode, 'default'). % Default warning handling mode - -% Dynamically show all available options with descriptions in the required format, grouped and halt -show_help_options_no_halt :- - findall([Name, DefaultValue, Type, Help, Group], - option_value_name_default_type_help(Name, DefaultValue, Type, Help, Group), - Options), - max_name_length(Options, MaxLen), - format(" First value is the default; if a brown value is listed, it is the Rust compatibility default:\n\n"), - group_options(Options, MaxLen),!. - -show_help_options:- - show_help_options_no_halt, - halt. - -% Calculate the maximum length of option names -max_name_length(Options, MaxLen) :- - findall(Length, (member([Name, _, _, _, _], Options), atom_length(Name, Length)), Lengths), - max_list(Lengths, MaxLen). - -% Group the options by category and print them -group_options(Options, MaxLen) :- - findall(Group, member([_, _, _, _, Group], Options), Groups), - list_to_set(Groups, SortedGroups), - print_groups(SortedGroups, Options, MaxLen). - - -% Print options by group with clarification for defaults and Rust compatibility -print_groups([], _, _). -print_groups([Group | RestGroups], Options, MaxLen) :- - format(" ~w:\n", [Group]), - print_group_options(Group, Options, MaxLen), - format("\n"), - print_groups(RestGroups, Options, MaxLen). - -% Print options in each group, aligned to the longest option name, mentioning Rust changes explicitly -print_group_options(_, [], _). -print_group_options(Group, [[Name, DefaultValue, Type, Help, Group] | Rest], MaxLen) :- - % Remove duplicates from the list of values - list_to_set(Type, UniqueValues), - list_to_set([DefaultValue|Type], [_,_|UniqueValues2]), - % Define the column where the comment should start - CommentColumn is 60, % Adjust this number to set the comment column position - ( (UniqueValues = [DefaultValue | RestOfValues]) - -> % Print default first, then other values, omit empty lists - (format_value_list(RestOfValues, CleanRest), - ( (CleanRest \= '') - -> format(" --~w~*t=<\033[1;37m~w\033[0m|~w> \033[~dG ~w\n", [Name, MaxLen, DefaultValue, CleanRest, CommentColumn, Help]) - ; format(" --~w~*t=<\033[1;37m~w\033[0m> \033[~dG ~w\n", [Name, MaxLen, DefaultValue, CommentColumn, Help]) - )) - ; % Case 2: If the default value is not first, list default first and mark the first value as Rust-specific - (UniqueValues = [RustSpecificValue | _RestOfValues], - DefaultValue \= RustSpecificValue) - -> % Print default first, mark the Rust value in brown, then other values, omit empty lists - (format_value_list(UniqueValues2, CleanRest), - ( (CleanRest \= '') - -> format(" --~w~*t=<\033[1;37m~w\033[0m|\033[38;5;94m~w\033[0m|~w> \033[~dG ~w\n", [Name, MaxLen, DefaultValue, RustSpecificValue, CleanRest, CommentColumn, Help]) - ; format(" --~w~*t=<\033[1;37m~w\033[0m|\033[38;5;94m~w\033[0m> \033[~dG ~w\n", [Name, MaxLen, DefaultValue, RustSpecificValue, CommentColumn, Help]) - )) - ), - print_group_options(Group, Rest, MaxLen). - -print_group_options(Group, [_ | Rest], MaxLen) :- - print_group_options(Group, Rest, MaxLen). - -% Helper to print the list of values without square brackets -format_value_list([], ''). -format_value_list([H], H) :- !. -format_value_list([H|T], Formatted) :- - format_value_list(T, Rest), - format(atom(Formatted), "~w|~w", [H, Rest]). - - - -%fbugio(TF,P):-!, ignore(( TF,!,write_src_uo(fbug(P)))). -%fbugio(_,_):- is_compatio,!. -fbugio(TF,P):-!, ignore(( TF,!,fbug(P))). -fbugio(IO):-fbugio(true,IO). - -different_from(N,V):- \+ \+ option_value_def(N,V),!,fail. -different_from(N,V):- \+ \+ nb_current(N,V),!,fail. -different_from(_,_). - -set_option_value_interp(N,V):- symbol(N), symbolic_list_concat(List,',',N),List\=[_],!, - forall(member(E,List),set_option_value_interp(E,V)). -set_option_value_interp(N,V):- - %(different_from(N,V)->Note=true;Note=false), - Note = true, - fbugio(Note,set_option_value(N,V)),set_option_value(N,V), - ignore(forall(on_set_value(Note,N,V),true)). - -on_set_value(Note,N,'True'):- on_set_value(Note,N,true). -on_set_value(Note,N,'False'):- on_set_value(Note,N,false). -on_set_value(_Note,log,true):- switch_to_mettalog. -on_set_value(_Note,compatio,true):- switch_to_mettarust. -on_set_value(Note,N,V):- symbol(N), symbol_concat('trace-on-',F,N),fbugio(Note,set_debug(F,V)),set_debug(F,V). -on_set_value(Note,N,V):- symbol(N), is_debug_like(V,TF),fbugio(Note,set_debug(N,TF)),set_debug(N,TF). - - -%is_debug_like(false, false). -is_debug_like(trace, true). -is_debug_like(notrace, false). -is_debug_like(debug, true). -is_debug_like(nodebug, false). -is_debug_like(silent, false). - -'is-symbol'(X):- symbol(X). -%:- (is_mettalog->switch_to_mettalog;switch_to_mettarust). - -set_is_unit_test(TF):- - forall(option_value_def(A,B),set_option_value_interp(A,B)), - set_option_value_interp('trace-on-test',false), - set_option_value_interp('trace-on-fail',false), - set_option_value_interp('load',show), - set_option_value_interp('test',TF), - %set_option_value_interp('trace-on-load',TF), -/* if_t(TF,set_option_value_interp('exec',debug)), - if_t(TF,set_option_value_interp('eval',debug)), - set_option_value_interp('trace-on-exec',TF), - set_option_value_interp('trace-on-eval',TF),*/ - % if_t( \+ TF , set_prolog_flag(debug_on_interrupt,true)), - !. - -:- meta_predicate fake_notrace(0). -fake_notrace(G):- tracing,!,real_notrace(G). -fake_notrace(G):- !,notrace(G). -fake_notrace(G):- !,once(G). -% `quietly/1` allows breaking in and inspection (real `no_trace/1` does not) -fake_notrace(G):- quietly(G),!. -:- meta_predicate real_notrace(0). -real_notrace(Goal) :- - setup_call_cleanup('$notrace'(Flags, SkipLevel), - once(Goal), - '$restore_trace'(Flags, SkipLevel)). - - -:- dynamic(is_answer_output_stream/2). - -%answer_output(Stream):- is_testing,original_user_output(Stream),!. -%answer_output(Stream):- !,original_user_output(Stream),!. % yes, the cut is on purpose -answer_output(Stream) :- - is_answer_output_stream(_, Stream), !. % Use existing stream if already open -answer_output(Stream) :- - new_memory_file(MemFile), % Create a new memory file - open_memory_file(MemFile, write, Stream, [encoding(utf8)]), % Open it as a stream - asserta(is_answer_output_stream(MemFile, Stream)). % Store memory file and stream reference - -write_answer_output :- - retract(is_answer_output_stream(MemFile, Stream)), !, % Retrieve and remove memory file reference - ignore(catch_log(close(Stream))), % Close the stream - memory_file_to_string(MemFile, String), % Read contents from the memory file - write(String), % Write the contents to output - free_memory_file(MemFile). % Free the memory file -write_answer_output. - -:- at_halt(write_answer_output). % Ensure cleanup at halt - - -with_answer_output(Goal, S) :- - new_memory_file(MemFile), % Create a new memory file - open_memory_file(MemFile, write, Stream, [encoding(utf8)]), % Open it as a stream - asserta(is_answer_output_stream(MemFile, Stream), Ref), - setup_call_cleanup( - true, - (call(Goal)), % Execute the Goal - ( - close(Stream), % Close the stream after Goal - memory_file_to_string(MemFile, S), % Retrieve content as a string - free_memory_file(MemFile), % Free the memory file - erase(Ref) % Retract the temporary predicate - ) - ). - -null_io(G):- null_user_output(Out), !, with_output_to(Out,G). -user_io(G):- current_prolog_flag(mettalog_rt, true), !, original_user_error(Out), ttyflush, !, with_output_to(Out,G), flush_output(Out), ttyflush. -user_io(G):- original_user_output(Out), ttyflush, !, with_output_to(Out,G), flush_output(Out), ttyflush. -user_err(G):- original_user_error(Out), !, with_output_to(Out,G). -with_output_to_s(Out,G):- current_output(COut), - redo_call_cleanup(set_prolog_IO(user_input, Out,user_error), G, - set_prolog_IO(user_input,COut,user_error)). - -not_compatio(G):- nb_current(in_not_compatio, true),!,call(G). -not_compatio(G):- if_t(once(is_mettalog;is_testing; (\+ is_compatio )), - user_err( locally(nb_setval(in_not_compatio, true), G))). - - extra_answer_padding(_). - - -%! in_answer_io(+G) is det. -% -% Main predicate for executing a goal while capturing its output and handling it appropriately. -% This predicate first checks if the answer output is suspended via `nb_current/2`. -% If output is not suspended, it captures the output based on the streams involved. -% -% @arg G The goal to be executed. -in_answer_io(_):- nb_current(suspend_answers,true),!. -in_answer_io(G) :- - % Get the answer_output stream - answer_output(AnswerOut), - % Get the current output stream - current_output(CurrentOut), - % Get the standard output stream via file_no(1) - get_stdout_stream(StdOutStream), - % If the output is already visible to the user, execute G directly - (( AnswerOut == CurrentOut ; AnswerOut == StdOutStream ) - -> call(G) - ; ( % Otherwise, capture and process the output - % Determine the encoding - stream_property(CurrentOut, encoding(CurrentEncoding0)), - ( CurrentEncoding0 == text - -> stream_property(AnswerOut, encoding(CurrentEncoding)) - ; CurrentEncoding = CurrentEncoding0 - ), - % Start capturing output per solution - capture_output_per_solution(G, CurrentOut, AnswerOut, StdOutStream, CurrentEncoding))). - -%! get_stdout_stream(-StdOutStream) is det. -% -% Helper predicate to retrieve the standard output stream. -%This uses `current_stream/3` to find the stream associated with file descriptor 1 (stdout). -% -%@argStdOutStreamUnifieswiththestandardoutputstream. -get_stdout_stream(StdOutStream) :- - current_stream(_, write, StdOutStream), - stream_property(StdOutStream, file_no(1)),!. - -%! capture_output_per_solution(+G, +CurrentOut, +AnswerOut, +StdOutStream, +CurrentEncoding) is det. -% -% Captures and processes the output for each solution of a nondeterministic goal. -%Usesamemoryfiletotemporarilystoretheoutputandthenfinalizestheoutputhandling. -% -%@argGThegoalwhoseoutputisbeingcaptured. -%@argCurrentOutThecurrentoutputstream. -%@argAnswerOutTheansweroutputstream. -%@argStdOutStreamThestandardoutputstream. -%@argCurrentEncodingTheencodingusedforcapturingandwritingoutput. -capture_output_per_solution(G, CurrentOut, AnswerOut, StdOutStream, CurrentEncoding) :- - % Prepare initial memory file and write stream - State = state(_, _), - set_output_to_memfile(State, CurrentEncoding), - % Use setup_call_catcher_cleanup to handle execution and cleanup - setup_call_catcher_cleanup( - true, - ( - (call(G), - % Check determinism after G succeeds - deterministic(Det)), - % Process the captured output - process_and_finalize_output(State, CurrentOut, AnswerOut, StdOutStream, CurrentEncoding), - % If there are more solutions, prepare for the next one - ( Det == false - -> % Prepare a new memory file and write stream for the next solution - set_output_to_memfile(State,CurrentEncoding) - ; % If deterministic, leave cleanup for process_and_finalize_output - true - ) - ), - Catcher, - ( - % Final cleanup - process_and_finalize_output(State, CurrentOut, AnswerOut, StdOutStream, CurrentEncoding) - ) - ), - % Handle exceptions and failures - handle_catcher(Catcher). - -%! set_output_to_memfile(+State, +CurrentEncoding) is det. -% -% Creates a new memory file and write stream for capturing output and updates the State. -% This predicate also sets the output stream to the new memory file's write stream. -% -% @arg State The state holding the memory file and write stream. -% @arg CurrentEncoding The encoding to use for the memory file. -set_output_to_memfile(State,CurrentEncoding):- - % Create a new memory file. - new_memory_file(NewMemFile), - % Open the memory file for writing with the specified encoding. - open_memory_file(NewMemFile, write, NewWriteStream, [encoding(CurrentEncoding)]), - % Update the state with the new memory file and write stream (non-backtrackable). - nb_setarg(1, State, NewMemFile), - nb_setarg(2, State, NewWriteStream), - % Redirect output to the new write stream. - set_output(NewWriteStream). - -%! process_and_finalize_output(+State, +CurrentOut, +AnswerOut, +StdOutStream, +CurrentEncoding) is det. -% -% Finalizes the captured output, closing streams and writing content to the necessary output streams. -% This also handles freeing up memory resources and transcodes content if necessary. -% -% @arg State The current state holding the memory file and write stream. -% @arg CurrentOut The original output stream to restore after processing. -% @arg AnswerOut The stream to write the captured output to. -% @arg StdOutStream The standard output stream. -% @arg CurrentEncoding The encoding used for reading and writing the output. -process_and_finalize_output(State, CurrentOut, AnswerOut, StdOutStream, CurrentEncoding) :- - % Retrieve the memory file and write stream from the state. - arg(1, State, MemFile), - arg(2, State, WriteStream), - % Close the write stream to flush the output - (nonvar(WriteStream) -> (close(WriteStream),nb_setarg(2, State, _)) ; true), - % Reset the output stream to its original state - set_output(CurrentOut), - % Read the captured content from the memory file - (nonvar(MemFile) -> - (nb_setarg(1, State, _), - open_memory_file(MemFile, read, ReadStream, [encoding(CurrentEncoding)]), - read_string(ReadStream, _, Content), - close(ReadStream), - % Free the memory file - free_memory_file(MemFile), - % Write the content to the streams, handling encoding differences - write_to_stream(AnswerOut, Content, CurrentEncoding), - ( AnswerOut \== StdOutStream -> nop(write_to_stream(user_error, Content, CurrentEncoding)) ; true )) ; true). - - -%! handle_catcher(+Catcher) is det. -% -% Handles the `setup_call_catcher_cleanup/4` catcher to determine how to proceed after execution. -% -% @arg Catcher The result of the call (either success, failure, or exception). -handle_catcher(Var) :- - % If the catcher is unbound, the call succeeded. - var(Var), !. -handle_catcher(exit). % Success, do nothing. -handle_catcher(fail) :- fail. % Failure, propagate it. -handle_catcher(exception(Exception)) :- throw(Exception). % Exception, re-throw it. - -%! write_to_stream(+Stream, +Content, +ContentEncoding) is det. -% -% Writes the given content to the specified stream, handling encoding differences between the content and the stream. -% -% @arg Stream The stream to write to. -% @arg Content The content to be written. -% @arg ContentEncoding The encoding of the content. -write_to_stream(Stream, Content, ContentEncoding) :- - % Retrieve the encoding of the destination stream. - stream_property(Stream, encoding(StreamEncoding)), - transcode_content(Content, ContentEncoding, StreamEncoding, TranscodedContent), - with_output_to(Stream, write(TranscodedContent)). - -%! transcode_content(+Content, +FromEncoding, +ToEncoding, -TranscodedContent) is det. -% -% Transcodes content from one encoding to another by writing it to a temporary memory file. -% -% @arg Content The original content. -% @arg FromEncoding The encoding of the original content. -% @arg ToEncoding The target encoding. -% @arg TranscodedContent The resulting content in the target encoding. -transcode_content(Content, SameEncoding, SameEncoding, Content) :- !. -transcode_content(Content, FromEncoding, ToEncoding, TranscodedContent) :- - % Write the content to a temporary memory file with the original encoding. - new_memory_file(TempMemFile), - open_memory_file(TempMemFile, write, TempWriteStream, [encoding(FromEncoding)]), - write(TempWriteStream, Content), - close(TempWriteStream), - % Read the content from the memory file with the target encoding. - open_memory_file(TempMemFile, read, TempReadStream, [encoding(ToEncoding), encoding_errors(replace)]), - read_string(TempReadStream, _, TranscodedContent), - close(TempReadStream), - % Free the temporary memory file. - free_memory_file(TempMemFile). - - -%if_compatio(G):- if_t(is_compatio,user_io(G)). -% if_compat_io(G):- if_compatio(G). -not_compat_io(G):- not_compatio(G). -non_compat_io(G):- not_compatio(G). - - -trace_on_pass:- false. -trace_on_fail:- option_value('trace-on-fail',true). -trace_on_overflow:- option_value('trace-on-overflow',true). -doing_repl:- option_value('doing_repl',true). -if_repl(Goal):- doing_repl->call(Goal);true. - -any_floats(S):- member(E,S),float(E),!. - -show_options_values:- - forall((nb_current(N,V), \+((symbol(N),symbol_concat('$',_,N)))),write_src_nl(['pragma!',N,V])). - -:- prolog_load_context(source,File), assert(interpreter_source_file(File)). - - -:- ensure_loaded(metta_utils). -%:- ensure_loaded(mettalog('metta_ontology.pfc.pl')). -:- ensure_loaded(metta_pfc_base). -:- ensure_loaded(metta_pfc_support). -:- ensure_loaded(metta_compiler). -:- ensure_loaded(metta_convert). -:- ensure_loaded(metta_types). -:- ensure_loaded(metta_space). -:- ensure_loaded(metta_eval). - -:- set_is_unit_test(false). -extract_prolog_arity([Arrow|ParamTypes],PrologArity):- - Arrow == ('->'),!, - len_or_unbound(ParamTypes,PrologArity). - -add_prolog_code(_KB,AssertZIfNew):- - fbug(writeln(AssertZIfNew)), - assertz_if_new(AssertZIfNew). -gen_interp_stubs(KB,Symb,Def):- - ignore((is_list(Def), - must_det_ll(( - extract_prolog_arity(Def,PrologArity), - symbol(Symb), - symbol_concat('i_',Symb,Tramp), - length(PrologArgs,PrologArity), - append(MeTTaArgs,[RetVal],PrologArgs), - TrampH =.. [Tramp|PrologArgs], - add_prolog_code(KB, - (TrampH :- eval_H([Symb|MeTTaArgs], RetVal))))))). - -% 'int_fa_format-args'(FormatArgs, Result):- eval_H(['format-args'|FormatArgs], Result). -% 'ext_fa_format-args'([EFormat, EArgs], Result):- int_format-args'(EFormat, EArgs, Result) -/* - -'ext_format-args'(Shared,Format, Args, EResult):- - pred_in('format-args',Shared,3), - argn_in(1,Shared,Format,EFormat), - argn_in(2,Shared,Args,EArgs), - argn_in(3,Shared,EResult,Result), - int_format-args'(Shared,EFormat, EArgs, Result), - arg_out(1,Shared,EFormat,Format), - arg_out(2,Shared,EArgs,Args), - arg_out(3,Shared,Result,EResult). - - you are goign to create the clause based on the first 2 args - -?- gen_form_body('format-args',3, HrnClause). - -HrnClause = - ('ext_format-args'(Shared, Arg1, Arg2, EResult):- - pred_in('format-args',Shared,3), - argn_in(1,Shared,Arg1,EArg1), - argn_in(2,Shared,Arg2,EArg2), - argn_in(3,Shared,EResult,Result), - 'int_format-args'(Shared,EArg1, EArg2, Result), - arg_out(1,Shared,EArg1,Arg1), - arg_out(2,Shared,EArg2,Arg2), - arg_out(3,Shared,Result,EResult)). - -*/ - - - -% Helper to generate head of the clause -generate_head(Shared,Arity, FormName, Args, Head) :- - atom_concat('ext_', FormName, ExtFormName), - number_string(Arity, ArityStr), - atom_concat(ExtFormName, ArityStr, FinalFormName), % Append arity to form name for uniqueness - append([FinalFormName, Shared | Args], HeadArgs), - Head =.. HeadArgs. - -% Helper to generate body of the clause, swapping arguments -generate_body(Shared,Arity, FormName, Args, EArgs, Body) :- - atom_concat('int_', FormName, IntFormName), - number_string(Arity, ArityStr), - atom_concat(IntFormName, ArityStr, FinalIntFormName), % Append arity to internal form name for uniqueness - reverse(EArgs, ReversedEArgs), % Reverse the order of evaluated arguments for internal processing - % Generate predicates for input handling - findall(argn_in(Index, Shared, Arg, EArg), - (nth1(Index, Args, Arg), nth1(Index, EArgs, EArg)), ArgIns), - % Internal processing call with reversed arguments - append([Shared | ReversedEArgs], IntArgs), - InternalCall =.. [FinalIntFormName | IntArgs], - % Generate predicates for output handling - findall(arg_out(Index, Shared, EArg, Arg), - (nth1(Index, EArgs, EArg), nth1(Index, Args, Arg)), ArgOuts), - % Combine predicates - PredIn = pred_in(FormName, Shared, Arity), - append([PredIn | ArgIns], [InternalCall | ArgOuts], BodyParts), - list_to_conjunction(BodyParts, Body). - -% Main predicate to generate form body clause -gen_form_body(FormName, Arity, Clause) :- - length(Args,Arity), - length(EArgs,Arity), - generate_head(Shared,Arity, FormName, Args, Head), - generate_body(Shared,Arity, FormName, Args, EArgs, Body), - Clause = (Head :- Body). - - -% Helper to format atoms -format_atom(Format, N, Atom) :- format(atom(Atom), Format, [N]). - - -% 'int_format-args'(Shared,Format, Args, Result):- -% .... actual impl .... - - -% ============================ -% %%%% Missing Arithmetic Operations -% ============================ -'%'(Dividend, Divisor, Remainder):- eval_H(['mod',Dividend, Divisor], Remainder). - - -mettalog_rt_args(Args):- current_prolog_flag(mettalog_rt_args, Args),!. -mettalog_rt_args(['--repl=false']). - -metta_argv(Args):- current_prolog_flag(metta_argv, Args),!. -metta_argv(Args):- current_prolog_flag(mettalog_rt, true),!,mettalog_rt_args(Args). -metta_argv(Before):- current_prolog_flag(os_argv,OSArgv), append(_,['--args'|AArgs],OSArgv), - before_arfer_dash_dash(AArgs,Before,_),!,set_metta_argv(Before). -argv_metta(Nth,Value):- metta_argv(Args),nth1(Nth,Args,Value). - -set_metta_argv(Before):- maplist(read_argv,Before,Args),set_prolog_flag(metta_argv, Args),!. -read_argv(AArg,Arg):- \+ symbol(AArg),!,AArg=Arg. -read_argv(AArg,Arg):- atom_string(AArg,S),read_metta(S,Arg),!. - - -metta_cmd_args(Args):- current_prolog_flag(mettalog_rt, true),!,mettalog_rt_args(Args). -metta_cmd_args(Rest):- current_prolog_flag(late_metta_opts,Rest),!. -metta_cmd_args(Rest):- current_prolog_flag(os_argv,P),append(_,['--'|Rest],P),!. -metta_cmd_args(Rest):- current_prolog_flag(argv,P),append(_,['--'|Rest],P),!. -metta_cmd_args(Rest):- current_prolog_flag(argv,Rest). - -:- dynamic(has_run_cmd_args/0). -:- volatile(has_run_cmd_args/0). -run_cmd_args_prescan:- has_run_cmd_args, !. -run_cmd_args_prescan:- assert(has_run_cmd_args), do_cmdline_load_metta(prescan). - -run_cmd_args:- - run_cmd_args_prescan, - set_prolog_flag(debug_on_interrupt,true), - do_cmdline_load_metta(execute). - - -metta_make_hook:- loonit_reset, option_value(not_a_reload,true),!. -metta_make_hook:- - metta_cmd_args(Rest), into_reload_options(Rest,Reload), do_cmdline_load_metta(reload,'&self',Reload). - -:- multifile(prolog:make_hook/2). -:- dynamic(prolog:make_hook/2). -prolog:make_hook(after, _Some):- nop( metta_make_hook). - -into_reload_options(Reload,Reload). - -is_cmd_option(Opt,M, TF):- symbol(M), - symbol_concat('-',Opt,Flag), - atom_contains(M,Flag),!, - get_flag_value(M,FV), - TF=FV. - -get_flag_value(M,V):- symbolic_list_concat([_,V],'=',M),!. -get_flag_value(M,false):- atom_contains(M,'-no'),!. -get_flag_value(_,true). - - -:- ignore((( - \+ prolog_load_context(reloading,true), - nop((forall(option_value_def(Opt,Default),set_option_value_interp(Opt,Default))))))). - -%process_option_value_def:- \+ option_value('python',false), skip(ensure_loaded(metta_python)). -process_option_value_def:- fail, \+ option_value('python',false), ensure_loaded(mettalog(metta_python)), - real_notrace((ensure_mettalog_py)). -process_option_value_def. - - -process_late_opts:- forall(process_option_value_def,true). -process_late_opts:- once(option_value('html',true)), set_is_unit_test(true). -%process_late_opts:- current_prolog_flag(os_argv,[_]),!,ignore(repl). -%process_late_opts:- halt(7). -process_late_opts. - - -do_cmdline_load_metta(Phase):- metta_cmd_args(Rest), !, do_cmdline_load_metta(Phase,'&self',Rest). - -%do_cmdline_load_metta(Phase,_Slf,Rest):- select('--prolog',Rest,RRest),!, -% set_option_value_interp('prolog',true), -% set_prolog_flag(late_metta_opts,RRest). -do_cmdline_load_metta(Phase,Self,Rest):- - set_prolog_flag(late_metta_opts,Rest), - forall(process_option_value_def,true), - cmdline_load_metta(Phase,Self,Rest),!, - forall(process_late_opts,true). - -:- if( \+ current_predicate(load_metta_file/2)). -load_metta_file(Self,Filemask):- symbol_concat(_,'.metta',Filemask),!, load_metta(Self,Filemask). -load_metta_file(_Slf,Filemask):- load_flybase(Filemask). -:- endif. - -catch_abort(From,Goal):- - catch_abort(From,Goal,Goal). -catch_abort(From,TermV,Goal):- - catch(Goal,'$aborted',fbug(aborted(From,TermV))). -% done - -before_arfer_dash_dash(Rest,Args,NewRest):- - append(Args,['--'|NewRest],Rest)->true;([]=NewRest,Args=Rest). - -cmdline_load_metta(_,_,Nil):- Nil==[],!. - -cmdline_load_metta(Phase,Self,['--'|Rest]):- !, - cmdline_load_metta(Phase,Self,Rest). - -cmdline_load_metta(Phase,Self,['--args'|Rest]):- !, - before_arfer_dash_dash(Rest,Before,NewRest),!, - set_metta_argv(Before), - cmdline_load_metta(Phase,Self,NewRest). - -cmdline_load_metta(Phase,Self,['--repl'|Rest]):- !, - if_phase(Phase,execute,repl), - cmdline_load_metta(Phase,Self,Rest). -cmdline_load_metta(Phase,Self,['--log'|Rest]):- !, - if_phase(Phase,execute,switch_to_mettalog), - cmdline_load_metta(Phase,Self,Rest). -cmdline_load_metta(Phase,Self,[Filemask|Rest]):- symbol(Filemask), \+ symbol_concat('-',_,Filemask), - if_phase(Phase,execute,cmdline_load_file(Self,Filemask)), - cmdline_load_metta(Phase,Self,Rest). - -cmdline_load_metta(Phase,Self,['-g',M|Rest]):- !, - if_phase(Phase,execute,catch_abort(['-g',M],((read_term_from_atom(M, Term, []),ignore(call(Term)))))), - cmdline_load_metta(Phase,Self,Rest). - -cmdline_load_metta(Phase,Self,['-G',Str|Rest]):- !, - current_self(Self), - if_phase(Phase,execute,catch_abort(['-G',Str],ignore(call_sexpr('!',Self,Str,_S,_Out)))), - cmdline_load_metta(Phase,Self,Rest). - -cmdline_load_metta(Phase,Self,[M|Rest]):- - m_opt(M,Opt), - is_cmd_option(Opt,M,TF), - fbug(is_cmd_option(Phase,Opt,M,TF)), - set_option_value_interp(Opt,TF), !, - %set_tty_color_term(true), - cmdline_load_metta(Phase,Self,Rest). - -cmdline_load_metta(Phase,Self,[M|Rest]):- - format('~N'), fbug(unused_cmdline_option(Phase,M)), !, - cmdline_load_metta(Phase,Self,Rest). - - -install_ontology:- ensure_corelib_types. -load_ontology:- option_value(compile,false),!. -load_ontology. - -%cmdline_load_file(Self,Filemask):- is_converting,!, - -cmdline_load_file(Self,Filemask):- - Src=(user:load_metta_file(Self,Filemask)), - catch_abort(Src, - (must_det_ll(( - not_compatio((nl,write('; '),write_src(Src),nl)), - catch_red(Src),!,flush_output)))),!. - -if_phase(Current,Phase,Goal):- ignore((sub_var(Current,Phase),!, Goal)). - -set_tty_color_term(TF):- - current_output(X),set_stream(X,tty(TF)), - set_stream(X, encoding(utf8)), - set_stream(current_output,tty(TF)), - set_stream(current_output, encoding(utf8)), - set_prolog_flag(color_term ,TF). - -m_opt(M,Opt):- - m_opt0(M,Opt1), - m_opt1(Opt1,Opt). - -m_opt1(Opt1,Opt):- symbolic_list_concat([Opt|_],'=',Opt1). - -m_opt0(M,Opt):- symbol_concat('--no-',Opt,M),!. -m_opt0(M,Opt):- symbol_concat('--',Opt,M),!. -m_opt0(M,Opt):- symbol_concat('-',Opt,M),!. - -:- set_prolog_flag(occurs_check,true). - -start_html_of(_Filename):- \+ tee_file(_TEE_FILE),!. -start_html_of(_Filename):-!. -start_html_of(_Filename):- - must_det_ll(( - S = _, - %retractall(metta_eq_def(Eq,S,_,_)), - nop(retractall(metta_type(S,_,_))), - %retractall(get_metta_atom(Eq,S,_,_,_)), - loonit_reset, - tee_file(TEE_FILE), - sformat(S,'cat /dev/null > "~w"',[TEE_FILE]), - - writeln(doing(S)), - ignore(shell(S)))). - -save_html_of(_Filename):- \+ tee_file(_TEE_FILE),!. -save_html_of(_):- \+ has_loonit_results, \+ option_value('html',true). -save_html_of(_):- loonit_report, !, writeln('
Return to summaries
'). -save_html_of(_Filename):-!. -save_html_of(Filename):- - must_det_ll(( - file_name_extension(Base,_,Filename), - file_name_extension(Base,'metta.html',HtmlFilename), - loonit_reset, - tee_file(TEE_FILE), - writeln('
Return to summaries
'), - sformat(S,'ansi2html -u < "~w" > "~w" ',[TEE_FILE,HtmlFilename]), - writeln(doing(S)), - ignore(shell(S)))). - -tee_file(TEE_FILE):- getenv('TEE_FILE',TEE_FILE),!. -tee_file(TEE_FILE):- metta_dir(Dir),directory_file_path(Dir,'TEE.ansi',TEE_FILE),!. - - -clear_spaces:- clear_space(_). -clear_space(S):- - retractall(user:loaded_into_kb(S,_)), - %retractall(metta_eq_def(_,S,_,_)), - nop(retractall(metta_type(S,_,_))), - retractall(metta_atom_asserted(S,_)). - -dcall(G):- call(G). - -lsm:- lsm(_). -lsm(S):- - listing(metta_file(S,_,_)), - %listing(mdyn_type(S,_,_,_)), - forall(mdyn_type(S,_,_,Src),color_g_mesg('#22a5ff',write_f_src(Src))), - nl,nl,nl, - forall(mdyn_defn(S,_,_,Src),color_g_mesg('#00ffa5',write_f_src(Src))), - %listing(mdyn_defn(S,_,_,_)), - !. - -write_f_src(H,B):- H=@=B,!,write_f_src(H). -write_f_src(H,B):- write_f_src(['=',H,B]). - -hb_f(HB,ST):- sub_term(ST,HB),(symbol(ST),ST\==(=),ST\==(:)),!. -write_f_src(HB):- - hb_f(HB,ST), - option_else(current_def,CST,[]),!, - (CST == ST -> true ; (nl,nl,nl,set_option_value_interp(current_def,ST))), - write_src(HB). - - - -debug_only(G):- notrace(ignore(catch_warn(G))). -debug_only(_What,G):- ignore((fail,notrace(catch_warn(G)))). - - -'True':- true. -'False':- fail. - - -'mettalog::vspace-main':- repl. - -into_underscores(D,U):- symbol(D),!,symbolic_list_concat(L,'-',D),symbolic_list_concat(L,'_',U). -into_underscores(D,U):- descend_and_transform(into_underscores,D,U),!. - - -descend_and_transform(P2, Input, Transformed) :- - ( var(Input) - -> Transformed = Input % Keep variables as they are - ; compound(Input) - -> (compound_name_arguments(Input, Functor, Args), - maplist(descend_and_transform(P2), Args, TransformedArgs), - compound_name_arguments(Transformed, Functor, TransformedArgs)) - ; (symbol(Input),call(P2,Input,Transformed)) - -> true % Transform atoms using xform_atom/2 - ; Transformed = Input % Keep other non-compound terms as they are - ). - -/* -is_syspred(H,Len,Pred):- notrace(is_syspred0(H,Len,Pred)). -is_syspred0(H,_Ln,_Prd):- \+ symbol(H),!,fail. -is_syspred0(H,_Ln,_Prd):- upcase_atom(H,U),downcase_atom(H,U),!,fail. -is_syspred0(H,Len,Pred):- current_predicate(H/Len),!,Pred=H. -is_syspred0(H,Len,Pred):- symbol_concat(Mid,'!',H), H\==Mid, is_syspred0(Mid,Len,Pred),!. -is_syspred0(H,Len,Pred):- into_underscores(H,Mid), H\==Mid, is_syspred0(Mid,Len,Pred),!. - -fn_append(List,X,Call):- - fn_append1(List,X,ListX), - into_fp(ListX,Call). - - - - - -is_metta_data_functor(Eq,F):- - current_self(Self),is_metta_data_functor(Eq,Self,F). - -is_metta_data_functor(Eq,Other,H):- - metta_type(Other,H,_), - \+ get_metta_atom(Eq,Other,[H|_]), - \+ metta_eq_def(Eq,Other,[H|_],_). -*/ -is_function(F):- symbol(F). - -is_False(X):- X\=='True', (is_False1(X)-> true ; (eval_H(X,Y),is_False1(Y))). -is_False1(Y):- (Y==0;Y==[];Y=='False'). - -is_conz(Self):- compound(Self), Self=[_|_]. - -%dont_x(eval_H(Depth,Self,metta_if(A=1,symbol_concat(metta_,_,F). -needs_expanded(eval_H(Term,_),Expand):- !,sub_term(Expand,Term),compound(Expand),Expand\=@=Term, - compound(Expand), \+ is_conz(Expand), \+ is_ftVar(Expand), needs_expand(Expand). -needs_expanded([A|B],Expand):- sub_term(Expand,[A|B]), compound(Expand), \+ is_conz(Expand), \+ is_ftVar(Expand), needs_expand(Expand). - -fn_append1(eval_H(Term,X),X,eval_H(Term,X)):-!. -fn_append1(Term,X,eval_H(Term,X)). - - - - - -assert_preds(Self,Load,List):- is_list(List),!,maplist(assert_preds(Self,Load),List). -%assert_preds(_Self,_Load,_Preds):- \+ show_transpiler,!. -assert_preds(Self,Load,Preds):- - expand_to_hb(Preds,H,_B), - functor(H,F,A), %trace, - if_t((false,show_transpiler), - color_g_mesg_ok('#005288',( - ignore(( - % \+ predicate_property(H,defined), - %if_t(is_transpiling,catch_i(dynamic(F,A))), - if_t( \+ predicate_property(H,defined), - not_compatio(format(' :- ~q.~n',[dynamic(F/A)]))), - if_t(option_value('tabling','True'), - not_compatio(format(' :- ~q.~n',[table(F/A)]))))), - not_compatio(format('~N~n ~@',[portray_clause(Preds)]))))), - - %if_t(is_transpiling, if_t( \+ predicate_property(H, static), add_assertion(Self,Preds))), - % allow errors and warning rather than silently doing nothing as the clause above would have done - if_t(is_transpiling, add_assertion(Self,Preds)), - nop(metta_anew1(Load,Preds)). - - -%load_hook(_Load,_Hooked):- !. -load_hook(Load,Hooked):- - ignore(( \+ ((forall(load_hook0(Load,Hooked),true))))),!. - - -%rtrace_on_error(G):- catch(G,_,fail). -rtrace_on_error(G):- - catch_err(G,E, - (%notrace, - write_src_uo(E=G), - %catch(rtrace(G),E,throw(E)), - catch(rtrace(G),E,throw(give_up(E=G))), - throw(E))). - -rtrace_on_failure(G):- tracing,!,call(G). -rtrace_on_failure(G):- - catch_err((G*->true;(write_src_uo(rtrace_on_failure(G)), - ignore(rtrace(G)), - write_src_uo(rtrace_on_failure(G)), - !,fail)),E, - (%notrace, - write_src_uo(E=G), - %catch(rtrace(G),E,throw(E)), - catch(rtrace(G),E,throw(give_up(E=G))), - throw(E))). - -rtrace_on_failure_and_break(G):- tracing,!,call(G). -rtrace_on_failure_and_break(G):- - catch_err((G*->true;(write_src(rtrace_on_failure(G)), - ignore(rtrace(G)), - write_src(rtrace_on_failure(G)), - !,break,fail)),E, - (%notrace, - write_src_uo(E=G), - %catch(rtrace(G),E,throw(E)), - catch(rtrace(G),E,throw(give_up(E=G))), - throw(E))). - -assertion_hb(metta_eq_def(Eq,Self,H,B),Self,Eq,H,B):-!. -assertion_hb(metta_defn(Self,H,B),Self,'=',H,B):-!. -assertion_hb(metta_atom_asserted(KB,HB),Self,Eq,H,B):- !, assertion_hb(metta_atom(KB,HB),Self,Eq,H,B). -assertion_hb(metta_atom(Self,[Eq,H,B]),Self,Eq,H,B):- assertion_neck_cl(Eq),!. -assertion_hb(metta_defn(Eq,Self,H,B),Self,Eq,H,B):- assertion_neck_cl(Eq),!. -assertion_hb(asserted_metta_atom(Self,[Eq,H,B]),Self,Eq,H,B):- assertion_neck_cl(Eq),!. - -assertion_neck_cl(Eq):- \+ symbol(Eq),!,fail. -assertion_neck_cl('='). -assertion_neck_cl(':-'). - - -load_hook0(_,_):- \+ show_transpiler, !. % \+ is_transpiling, !. -load_hook0(Load,Assertion):- assertion_hb(Assertion,Self,Eq,H,B), - functs_to_preds([Eq,H,B],Preds), - assert_preds(Self,Load,Preds),!. -% old compiler hook -load_hook0(Load,Assertion):- - assertion_hb(Assertion,Self, Eq, H,B), - rtrace_on_error(compile_for_assert_eq(Eq, H, B, Preds)),!, - rtrace_on_error(assert_preds(Self,Load,Preds)). -load_hook0(_,_):- \+ current_prolog_flag(metta_interp,ready),!. -/* -load_hook0(Load,get_metta_atom(Eq,Self,H)):- B = 'True', - H\=[':'|_], functs_to_preds([=,H,B],Preds), - assert_preds(Self,Load,Preds). -*/ -is_transpiling:- use_metta_compiler. -use_metta_compiler:- notrace(option_value('compile','full')), !. -preview_compiler:- \+ option_value('compile',false), !. -%preview_compiler:- use_metta_compiler,!. -show_transpiler:- option_value('code',Something), Something\==silent,!. -show_transpiler:- preview_compiler. - -option_switch_pred(F):- - current_predicate(F/0),interpreter_source_file(File), - source_file(F, File), \+ \+ (member(Prefix,[is_,show_,trace_on_]), symbol_concat(Prefix,_,F)), - F \== show_help_options. - -do_show_option_switches :- - forall(option_switch_pred(F),(call(F)-> writeln(yes(F)); writeln(not(F)))). -do_show_options_values:- - forall((nb_current(N,V), \+((symbol(N),symbol_concat('$',_,N)))),write_src_nl(['pragma!',N,V])), - do_show_option_switches. - -:- dynamic(metta_atom_asserted/2). -:- multifile(metta_atom_asserted/2). -:- dynamic(metta_atom_asserted_deduced/2). -:- multifile(metta_atom_asserted_deduced/2). -metta_atom_asserted(X,Y):- - metta_atom_asserted_deduced(X,Y), - \+ clause(metta_atom_asserted(X,Y),true). - - -%get_metta_atom(Eq,KB, [F|List]):- KB='&flybase',fb_pred(F, Len), length(List,Len),apply(F,List). - - -get_metta_atom_from(KB,Atom):- metta_atom(KB,Atom). - -get_metta_atom(Eq,Space, Atom):- metta_atom(Space, Atom), \+ (Atom =[EQ,_,_], EQ==Eq). - -metta_atom(Atom):- current_self(KB),metta_atom(KB,Atom). -%metta_atom([Superpose,ListOf], Atom):- Superpose == 'superpose',is_list(ListOf),!,member(KB,ListOf),get_metta_atom_from(KB,Atom). -metta_atom(Space, Atom):- typed_list(Space,_,L),!, member(Atom,L). -metta_atom(KB, [F, A| List]):- KB=='&flybase',fb_pred_nr(F, Len),current_predicate(F/Len), length([A|List],Len),apply(F,[A|List]). -%metta_atom(KB,Atom):- KB=='&corelib',!, metta_atom_corelib(Atom). -metta_atom(KB,Atom):- metta_atom_in_file( KB,Atom). -metta_atom(KB,Atom):- metta_atom_asserted( KB,Atom). - -%metta_atom(KB,Atom):- KB == '&corelib', !, metta_atom_asserted('&self',Atom). -metta_atom(KB,Atom):- KB \== '&corelib', using_all_spaces,!, metta_atom('&corelib',Atom). -metta_atom(KB,Atom):- KB \== '&corelib', !, metta_atom('&corelib',Atom). -metta_atom(KB,Atom):- KB \== '&corelib', !, - \+ \+ (metta_atom_asserted(KB,'&corelib'), - should_inherit_from_corelib(Atom)), !, - metta_atom('&corelib',Atom). -should_inherit_from_corelib(_):- using_all_spaces,!. -should_inherit_from_corelib([H,A|_]):- H == ':',!,nonvar(A). -should_inherit_from_corelib([H|_]):- H == '@doc', !. -should_inherit_from_corelib([H,A|T]):- fail, - H == '=',write_src_uo(try([H,A|T])),!,is_list(A), - A=[F|_],nonvar(F), F \==':', - \+ metta_atom_asserted('&self',[:,F|_]), - % \+ \+ metta_atom_asserted('&corelib',[=,[F|_]|_]), - write_src_uo([H,A|T]). - -/* -should_inherit_op_from_corelib('='). -should_inherit_op_from_corelib(':'). -should_inherit_op_from_corelib('@doc'). -%should_inherit_op_from_corelib(_). -*/ -metta_atom_asserted('&self','&corelib'). -metta_atom_asserted('&self','&stdlib'). -metta_atom_asserted('&stdlib','&corelib'). -metta_atom_asserted('&flybase','&corelib'). -metta_atom_asserted('&catalog','&corelib'). -metta_atom_asserted('&catalog','&stdlib'). - -/* -'mod-space'(top,'&self'). -'mod-space'(catalog,'&catalog'). -'mod-space'(corelib,'&corelib'). -'mod-space'(stdlib,'&stdlib'). -'mod-space'(Top,'&self'):- Top == self. -*/ -not_metta_atom_corelib(A,N):- A \== '&corelib' , metta_atom('&corelib',N). - -%metta_atom_asserted_fallback( KB,Atom):- metta_atom_stdlib(KB,Atom) - - -%metta_atom(KB,[F,A|List]):- metta_atom(KB,F,A,List), F \== '=',!. -is_metta_space(Space):- \+ \+ is_space_type(Space,_Test). - -%metta_eq_def(Eq,KB,H,B):- ignore(Eq = '='),if_or_else(metta_atom(KB,[Eq,H,B]), metta_atom_corelib(KB,[Eq,H,B])). -%metta_eq_def(Eq,KB,H,B):- ignore(Eq = '='),metta_atom(KB,[Eq,H,B]). -metta_eq_def(Eq,KB,H,B):- ignore(Eq = '='), if_or_else(metta_atom(KB,[Eq,H,B]),not_metta_atom_corelib(KB,[Eq,H,B])). - -%metta_defn(KB,Head,Body):- metta_eq_def(_Eq,KB,Head,Body). -%metta_defn(KB,H,B):- if_or_else(metta_atom(KB,['=',H,B]),not_metta_atom_corelib(KB,['=',H,B])). -metta_defn(KB,H,B):- metta_eq_def('=',KB,H,B). -%metta_type(KB,H,B):- if_or_else(metta_atom(KB,[':',H,B]),not_metta_atom_corelib(KB,[':',H,B])). -metta_type(KB,H,B):- metta_eq_def(':',KB,H,B). -%metta_type(S,H,B):- S == '&corelib', metta_atom_stdlib_types([':',H,B]). -%typed_list(Cmpd,Type,List):- compound(Cmpd), Cmpd\=[_|_], compound_name_arguments(Cmpd,Type,[List|_]),is_list(List). - -%metta_atom_corelib(KB,Atom):- KB\='&corelib',!,metta_atom('&corelib',Atom). - -%maybe_xform(metta_atom(KB,[F,A|List]),metta_atom(KB,F,A,List)):- is_list(List),!. -maybe_xform(metta_eq_def(Eq,KB,Head,Body),metta_atom(KB,[Eq,Head,Body])). -maybe_xform(metta_defn(KB,Head,Body),metta_atom(KB,['=',Head,Body])). -maybe_xform(metta_type(KB,Head,Body),metta_atom(KB,[':',Head,Body])). -maybe_xform(metta_atom(KB,HeadBody),metta_atom_asserted(KB,HeadBody)). -maybe_xform(_OBO,_XForm):- !, fail. - -metta_anew1(Load,_OBO):- var(Load),trace,!. -metta_anew1(Ch,OBO):- metta_interp_mode(Ch,Mode), !, metta_anew1(Mode,OBO). -metta_anew1(Load,OBO):- maybe_xform(OBO,XForm),!,metta_anew1(Load,XForm). -metta_anew1(load,OBO):- OBO= metta_atom(Space,Atom),!,'add-atom'(Space, Atom). -metta_anew1(unload,OBO):- OBO= metta_atom(Space,Atom),!,'remove-atom'(Space, Atom). -metta_anew1(unload_all,OBO):- OBO= forall(metta_atom(Space,Atom),ignore('remove-atom'(Space, Atom))). - -metta_anew1(load,OBO):- !, - must_det_ll((load_hook(load,OBO), - subst_vars(OBO,Cl), - pfcAdd_Now(Cl))). %to_metta(Cl). -metta_anew1(load,OBO):- !, - must_det_ll((load_hook(load,OBO), - subst_vars(OBO,Cl), - show_failure(pfcAdd_Now(Cl)))). -metta_anew1(unload,OBO):- subst_vars(OBO,Cl),load_hook(unload,OBO), - expand_to_hb(Cl,Head,Body), - predicate_property(Head,number_of_clauses(_)), - ignore((clause(Head,Body,Ref),clause(Head2,Body2,Ref), - (Head+Body)=@=(Head2+Body2),erase(Ref),pp_m(unload(Cl)))). -metta_anew1(unload_all,OBO):- subst_vars(OBO,Cl),load_hook(unload_all,OBO), - expand_to_hb(Cl,Head,Body), - predicate_property(Head,number_of_clauses(_)), - forall( - (clause(Head,Body,Ref),clause(Head2,Body2,Ref)), - must_det_ll((((Head+Body)=@=(Head2+Body2)) - ->(erase(Ref),nop(pp_m(unload_all(Ref,Cl)))) - ;(pp_m(unload_all_diff(Cl,(Head+Body)\=@=(Head2+Body2))))))). - - -/* -metta_anew2(Load,_OBO):- var(Load),trace,!. -metta_anew2(Load,OBO):- maybe_xform(OBO,XForm),!,metta_anew2(Load,XForm). -metta_anew2(Ch,OBO):- metta_interp_mode(Ch,Mode), !, metta_anew2(Mode,OBO). -metta_anew2(load,OBO):- must_det_ll((load_hook(load,OBO),subst_vars_not_last(OBO,Cl),assertz_if_new(Cl))). %to_metta(Cl). -metta_anew2(unload,OBO):- subst_vars_not_last(OBO,Cl),load_hook(unload,OBO), - expand_to_hb(Cl,Head,Body), - predicate_property(Head,number_of_clauses(_)), - ignore((clause(Head,Body,Ref),clause(Head2,Body2,Ref),(Head+Body)=@=(Head2+Body2),erase(Ref),pp_m(Cl))). -metta_anew2(unload_all,OBO):- subst_vars_not_last(OBO,Cl),load_hook(unload_all,OBO), - expand_to_hb(Cl,Head,Body), - predicate_property(Head,number_of_clauses(_)), - forall((clause(Head,Body,Ref),clause(Head2,Body2,Ref),(Head+Body)=@=(Head2+Body2),erase(Ref),pp_m(Cl)),true). -*/ - -metta_anew(Load,Src,OBO):- maybe_xform(OBO,XForm),!,metta_anew(Load,Src,XForm). -metta_anew(Ch, Src, OBO):- metta_interp_mode(Ch,Mode), !, metta_anew(Mode,Src,OBO). -metta_anew(Load,_Src,OBO):- silent_loading,!,metta_anew1(Load,OBO). -metta_anew(Load,Src,OBO):- - not_compat_io(( - output_language( metta, (if_show(load, color_g_mesg('#ffa500', ((format('~N '), write_src(Src))))))), - % format('~N'), - output_language( Load, (if_verbose(load,color_g_mesg('#4f4f0f', (( (write('; Action: '),writeq(Load=OBO),nl))))))), - true)), - metta_anew1(Load,OBO),not_compat_io((format('~N'))). - -subst_vars_not_last(A,B):- - functor(A,_F,N),arg(N,A,E), - subst_vars(A,B), - nb_setarg(N,B,E),!. - -con_write(W):-check_silent_loading, not_compat_io((write(W))). -con_writeq(W):-check_silent_loading, not_compat_io((writeq(W))). -writeqln(Q):- check_silent_loading,not_compat_io((write(' '),con_writeq(Q),connl)). - - -into_space(Self,'&self',Self):-!. -into_space(_,Other,Other):-!. - - -into_space(Self,Myself,SelfO):- into_space(30,Self,Myself,SelfO). - -into_space(_Dpth,Self,Myself,Self):-Myself=='&self',!. -into_space(_Dpth,Self,None,Self):- 'None' == None,!. -into_space(Depth,Self,Other,Result):- eval_H(Depth,Self,Other,Result). -into_name(_,Other,Other). - -%eval_f_args(Depth,Self,F,ARGS,[F|EARGS]):- maplist(eval_H(Depth,Self),ARGS,EARGS). - - -combine_result(TF,R2,R2):- TF == [], !. -combine_result(TF,_,TF):-!. - - -do_metta1_e(_Self,_,exec(Exec)):- !,write_exec(Exec),!. -do_metta1_e(_Self,_,[=,A,B]):- !, with_concepts(false, - (con_write('(= '), with_indents(false,write_src(A)), - (is_list(B) -> connl ; true), - con_write(' '),with_indents(true,write_src(B)),con_write(')'))),connl. -do_metta1_e(_Self,_LoadExec,Term):- write_src(Term),connl. - -write_exec(Exec):- real_notrace(write_exec0(Exec)). -%write_exec0(Exec):- symbol(Exec),!,write_exec0([Exec]). - -write_exec0(Exec):- - wots(S,write_src(exec(Exec))), - nb_setval(exec_src,Exec), - format('~N'), - output_language(metta,ignore((notrace((color_g_mesg('#0D6328',writeln(S))))))). - -%!(let* (( ($a $b) (collapse (get-atoms &self)))) ((bind! &stdlib $a) (bind! &corelib $b))) - -asserted_do_metta(Space,Ch,Src):- metta_interp_mode(Ch,Mode), !, asserted_do_metta(Space,Mode,Src). - -asserted_do_metta(Space,Load,Src):- Load==exec,!,do_metta_exec(python,Space,Src,_Out). -asserted_do_metta(Space,Load,Src):- asserted_do_metta2(Space,Load,Src,Src). - -asserted_do_metta2(Space,Ch,Info,Src):- nonvar(Ch), metta_interp_mode(Ch,Mode), !, asserted_do_metta2(Space,Mode,Info,Src). -/* -asserted_do_metta2(Self,Load,[TypeOp,Fn,Type], Src):- TypeOp == ':', \+ is_list(Type),!, - must_det_ll(( - color_g_mesg_ok('#ffa501',metta_anew(Load,Src,metta_atom(Self,[':',Fn,Type]))))),!. - -asserted_do_metta2(Self,Load,[TypeOp,Fn,TypeDecL], Src):- TypeOp == ':',!, - must_det_ll(( - decl_length(TypeDecL,Len),LenM1 is Len - 1, last_element(TypeDecL,LE), - color_g_mesg_ok('#ffa502',metta_anew(Load,Src,metta_atom(Self,[':',Fn,TypeDecL]))), - metta_anew1(Load,metta_arity(Self,Fn,LenM1)), - arg_types(TypeDecL,[],EachArg), - metta_anew1(Load,metta_params(Self,Fn,EachArg)),!, - metta_anew1(Load,metta_last(Self,Fn,LE)))). -*/ -/* -asserted_do_metta2(Self,Load,[TypeOp,Fn,TypeDecL,RetType], Src):- TypeOp == ':',!, - must_det_ll(( - decl_length(TypeDecL,Len), - append(TypeDecL,[RetType],TypeDecLRet), - color_g_mesg_ok('#ffa503',metta_anew(Load,Src,metta_atom(Self,[':',Fn,TypeDecLRet]))), - metta_anew1(Load,metta_arity(Self,Fn,Len)), - arg_types(TypeDecL,[RetType],EachArg), - metta_anew1(Load,metta_params(Self,Fn,EachArg)), - metta_anew1(Load,metta_return(Self,Fn,RetType)))),!. -*/ -/*do_metta(File,Self,Load,PredDecl, Src):-fail, - metta_anew(Load,Src,metta_atom(Self,PredDecl)), - ignore((PredDecl=['=',Head,Body], metta_anew(Load,Src,metta_eq_def(Eq,Self,Head,Body)))), - ignore((Body == 'True',!,do_metta(File,Self,Load,Head))), - nop((fn_append(Head,X,Head), fn_append(PredDecl,X,Body), - metta_anew((Head:- Body)))),!.*/ -/* -asserted_do_metta2(Self,Load,[EQ,Head,Result], Src):- EQ=='=', !, - color_g_mesg_ok('#ffa504',must_det_ll(( - discover_head(Self,Load,Head), - metta_anew(Load,Src,metta_eq_def(EQ,Self,Head,Result)), - discover_body(Self,Load,Result)))). -*/ -asserted_do_metta2(Self,Load,PredDecl, Src):- - %ignore(discover_head(Self,Load,PredDecl)), - color_g_mesg_ok('#ffa505',metta_anew(Load,Src,metta_atom(Self,PredDecl))). - -never_compile(X):- always_exec(X). - -always_exec(exec(W)):- !, is_list(W), always_exec(W). -always_exec(Comp):- compound(Comp),compound_name_arity(Comp,Name,N),symbol_concat('eval',_,Name),Nm1 is N-1, arg(Nm1,Comp,TA),!,always_exec(TA). -always_exec(List):- \+ is_list(List),!,fail. -always_exec([Var|_]):- \+ symbol(Var),!,fail. -always_exec(['extend-py!'|_]):- !, fail. -always_exec([H|_]):- symbol_concat(_,'!',H),!. %pragma!/print!/transfer!/include! etc -always_exec(['assertEqualToResult'|_]):-!,fail. -always_exec(['assertEqual'|_]):-!,fail. -always_exec(_):-!,fail. % everything else - -file_hides_results([W|_]):- W== 'pragma!'. - -if_t(A,B,C):- trace,if_t((A,B),C). - -check_answers_for(_,_):- nb_current(suspend_answers,true),!,fail. -check_answers_for(TermV,Ans):- (string(TermV);var(Ans);var(TermV)),!,fail. -check_answers_for(TermV,_):- sformat(S,'~q',[TermV]),atom_contains(S,"[assert"),!,fail. -check_answers_for(_,Ans):- contains_var('BadType',Ans),!,fail. -check_answers_for(TermV,_):- inside_assert(TermV,BaseEval), always_exec(BaseEval),!,fail. - -%check_answers_for([TermV],Ans):- !, check_answers_for(TermV,Ans). -%check_answers_for(TermV,[Ans]):- !, check_answers_for(TermV,Ans). -check_answers_for(_,_). - - /* -got_exec_result2(Val,Nth,Ans):- is_list(Ans), exclude(==(','),Ans,Ans2), Ans\==Ans2,!, - got_exec_result2(Val,Nth,Ans2). -got_exec_result2(Val,Nth,Ans):- - must_det_ll(( - Nth100 is Nth+100, - get_test_name(Nth100,TestName), - nb_current(exec_src,Exec), - if_t( ( \+ is_unit_test_exec(Exec)), - ((equal_enough(Val,Ans) - -> write_pass_fail_result_now(TestName,exec,Exec,'PASS',Ans,Val) - ; write_pass_fail_result_now(TestName,exec,Exec,'FAIL',Ans,Val)))))). - -write_pass_fail_result_now(TestName,exec,Exec,PASS_FAIL,Ans,Val):- - (PASS_FAIL=='PASS'->flag(loonit_success, X, X+1);flag(loonit_failure, X, X+1)), - (PASS_FAIL=='PASS'->Color=cyan;Color=red), - color_g_mesg(Color,write_pass_fail_result_c(TestName,exec,Exec,PASS_FAIL,Ans,Val)),!,nl, - nl,writeln('--------------------------------------------------------------------------'),!. - -write_pass_fail_result_c(TestName,exec,Exec,PASS_FAIL,Ans,Val):- - nl,write_mobj(exec,[(['assertEqualToResult',Exec,Ans])]), - nl,write_src('!'(['assertEqual',Val,Ans])), - write_pass_fail_result(TestName,exec,Exec,PASS_FAIL,Ans,Val). -*/ - -is_unit_test_exec(Exec):- sformat(S,'~w',[Exec]),sub_atom(S,_,_,_,'assert'). -is_unit_test_exec(Exec):- sformat(S,'~q',[Exec]),sub_atom(S,_,_,_,"!',"). - -make_empty(Empty):- 'Empty'=Empty. -make_empty(_,Empty):- make_empty(Empty). -make_empty(_RetType,_,Empty):- make_empty(Empty). - - -make_nop(Nop):- []=Nop. -make_nop(_,Nop):- make_nop(Nop). -make_nop(_RetType,_,Nop):- make_nop(Nop). - - -convert_tax(_How,Self,Tax,Expr,NewHow):- - metta_interp_mode(Ch,Mode), - string_concat(Ch,TaxM,Tax),!, - normalize_space(string(NewTax),TaxM), - convert_tax(Mode,Self,NewTax,Expr,NewHow). -convert_tax(How,_Self,Tax,Expr,How):- - %parse_sexpr_metta(Tax,Expr). - normalize_space(string(NewTax),Tax), - parse_sexpr_metta1(NewTax,Expr). - -%:- if( \+ current_predicate(notrace/1) ). -% notrace(G):- once(G). -%:- endif. - -metta_interp_mode('+',load). -metta_interp_mode('-',unload). -metta_interp_mode('--',unload_all). -metta_interp_mode('!',exec). -metta_interp_mode('?',call). -metta_interp_mode('^',load_like_file). - - -call_sexpr(How,Self,Tax,_S,Out):- - (symbol(Tax);string(Tax)), - normalize_space(string(TaxM),Tax), - convert_tax(How,Self,TaxM,Expr,NewHow),!, - show_call(do_metta(python,NewHow,Self,Expr,Out)). - -/* -do_metta(File,Load,Self,Cmt,Out):- - fail, - if_trace(do_metta, fbug(do_metta(File,Load,Self,Cmt,Out))),fail. -*/ - -do_metta(_File,_Load,_Self,In,Out):- var(In),!,In=Out. -do_metta(_From,_Mode,_Self,end_of_file,'Empty'):- !. %, halt(7), writeln('\n\n% To restart, use: ?- repl.'). -do_metta(_File,Load,_Self,Cmt,Out):- Load \==exec, Cmt==[],!, ignore(Out=[]). - -do_metta(From,Load,Self,'$COMMENT'(Expr,_,_),Out):- !, do_metta(From,comment(Load),Self,Expr,Out). -do_metta(From,Load,Self,'$STRING'(Expr),Out):- !, do_metta(From,comment(Load),Self,Expr,Out). -do_metta(From,comment(Load),Self,[Expr],Out):- !, do_metta(From,comment(Load),Self,Expr,Out). -do_metta(From,comment(Load),Self,Cmt,Out):- write_comment(Cmt), !, - ignore(( symbolic(Cmt),symbolic_list_concat([_,Src],'MeTTaLog only: ',Cmt),!,atom_string(Src,SrcCode),do_metta(mettalog_only(From),Load,Self,SrcCode,Out))), - ignore(( symbolic(Cmt),symbolic_list_concat([_,Src],'MeTTaLog: ',Cmt),!,atom_string(Src,SrcCode),do_metta(mettalog_only(From),Load,Self,SrcCode,Out))),!. - -do_metta(From,How,Self,Src,Out):- string(Src),!, - normalize_space(string(TaxM),Src), - convert_tax(How,Self,TaxM,Expr,NewHow),!, - do_metta(From,NewHow,Self,Expr,Out). - -do_metta(From,_,Self,exec(Expr),Out):- !, do_metta(From,exec,Self,Expr,Out). -do_metta(From,_,Self, call(Expr),Out):- !, do_metta(From,call,Self,Expr,Out). -do_metta(From,_,Self, ':-'(Expr),Out):- !, do_metta(From,call,Self,Expr,Out). -do_metta(From,call,Self,TermV,FOut):- !, - if_t(into_simple_op(call,TermV,OP),pfcAdd_Now('next-operation'(OP))), - call_for_term_variables(TermV,Term,NamedVarsList,X), must_be(nonvar,Term), - copy_term(NamedVarsList,Was), - Output = NamedVarsList, - user:interactively_do_metta_exec(From,Self,TermV,Term,X,NamedVarsList,Was,Output,FOut). - -do_metta(_File,Load,Self,Src,Out):- Load\==exec, !, - if_t(into_simple_op(Load,Src,OP),pfcAdd_Now('next-operation'(OP))), - dont_give_up(as_tf(asserted_do_metta(Self,Load,Src),Out)). - -do_metta(file(Filename),exec,Self,TermV,Out):- - must_det_ll((inc_exec_num(Filename), - get_exec_num(Filename,Nth), - Nth>0)), - (( - is_synthing_unit_tests, - file_answers(Filename, Nth, Ans), - check_answers_for(TermV,Ans))),!, - if_t(into_simple_op(exec,TermV,OP),pfcAdd_Now('next-operation'(OP))), - must_det_ll(( - ensure_increments((color_g_mesg_ok('#ffa509', - (writeln(';; In file as: '), - color_g_mesg([bold,fg('#FFEE58')], write_src(exec(TermV))), - write(';; To unit test case:'))),!, - call(do_metta_exec(file(Filename),Self,['assertEqualToResult',TermV,Ans],Out)))))). - -do_metta(From,exec,Self,TermV,Out):- !, - if_t(into_simple_op(exec,TermV,OP),pfcAdd_Now('next-operation'(OP))), - dont_give_up(do_metta_exec(From,Self,TermV,Out)). - -do_metta_exec(From,Self,TermV,FOut):- - Output = X, - %format("########################X0 ~w ~w ~w\n",[Self,TermV,FOut]), - (catch(((output_language(metta,write_exec(TermV)), - notrace(into_metta_callable(Self,TermV,Term,X,NamedVarsList,Was)),!, - %format("########################X1 ~w ~w ~w ~w\n",[Term,X,NamedVarsList,Output]), - user:interactively_do_metta_exec(From,Self,TermV,Term,X,NamedVarsList,Was,Output,FOut))), - give_up(Why),pp_m(red,gave_up(Why)))). - %format("########################X2 ~w ~w ~w\n",[Self,TermV,FOut]). - -a_e('assertEqual'). a_e('assertNotEqual'). -a_e('assertEqualToResult'). a_e('assertNotEqualToResult'). -o_s([AE|O],S):- nonvar(AE), a_e(AE), nonvar(O), o_s(O,S). -o_s([O|_],S):- nonvar(O), !, o_s(O,S). -o_s(S,S). -into_simple_op(Load,[Op|O],op(Load,Op,S)):- o_s(O,S),!. - -call_for_term_variables(TermV,catch_red(show_failure(Term)),NamedVarsList,X):- - term_variables(TermV, AllVars), call_for_term_variables4v(TermV,AllVars,Term,NamedVarsList,X),!, - must_be(callable,Term). -call_for_term_variables(TermV,catch_red(show_failure(Term)),NamedVarsList,X):- - get_term_variables(TermV, DCAllVars, Singletons, NonSingletons), - call_for_term_variables5(TermV, DCAllVars, Singletons, NonSingletons, Term,NamedVarsList,X),!, - must_be(callable,Term). - -into_metta_callable(_Self,TermV,Term,X,NamedVarsList,Was):- - \+ never_compile(TermV), - is_transpiling, !, - must_det_ll(((( - - % ignore(Res = '$VAR'('ExecRes')), - RealRes = Res, - compile_for_exec(Res,TermV,ExecGoal),!, - %format("~w ~w\n",[Res,ExecGoal]), - subst_vars(Res+ExecGoal,Res+Term,NamedVarsList), - copy_term_g(NamedVarsList,Was), - term_variables(Term,Vars), - - - Call = do_metta_runtime(Res, ExecGoal), - output_language(prolog, notrace((color_g_mesg('#114411', print_pl_source(:- Call ))))), - %nl,writeq(Term),nl, - ((\+ \+ - (( - %numbervars(v(TermV,Term,NamedVarsList,Vars),999,_,[attvar(skip)]), - %nb_current(variable_names,NamedVarsList), - %nl,print(subst_vars(Term,NamedVarsList,Vars)), - nop(nl))))), - nop(maplist(verbose_unify,Vars)), - %NamedVarsList=[_=RealRealRes|_], - %var(RealRes), - X = RealRes)))),!. - - -into_metta_callable(Self,TermV,CALL,X,NamedVarsList,Was):-!, - option_else('stack-max',StackMax,100), - CALL = eval_H(StackMax,Self,Term,X), - notrace(( must_det_ll(( - if_t(show_transpiler,write_compiled_exec(TermV,_Goal)), - subst_vars(TermV,Term,NamedVarsList), - copy_term_g(NamedVarsList,Was) - %term_variables(Term,Vars), - %nl,writeq(Term),nl, - %skip((\+ \+ - %((numbervars(v(TermV,Term,NamedVarsList,Vars),999,_,[attvar(bind)]), %nb_current(variable_names,NamedVarsList), - %nl,print(subst_vars(TermV,Term,NamedVarsList,Vars)),nl)))), - %nop(maplist(verbose_unify,Vars)))))),!. - )))),!. - - - -eval_S(Self,Form):- nonvar(Form), - current_self(SelfS),SelfS==Self,!, - do_metta(true,exec,Self,Form,_Out). -eval_H(Term,X):- catch_metta_return(eval_args(Term,X),X). - -eval_H(_StackMax,_Self, Term,Term):- fast_option_value(compile, save),!. -eval_H(StackMax,Self,Term,X):- catch_metta_return(eval_args('=',_,StackMax,Self,Term,X),X). -/* -eval_H(StackMax,Self,Term,X). - -eval_H(StackMax,Self,Term,X):- - Time = 90.0, - ((always_exec(Term)) -> - if_or_else(t1('=',_,StackMax,Self,Term,X), - (t2('=',_,StackMax,Self,Term,X))); - call_max_time(t1('=',_,StackMax,Self,Term,X), Time, - (t2('=',_,StackMax,Self,Term,X)))). - -eval_H(Term,X):- - current_self(Self), StackMax = 100, - if_or_else((t1('=',_,StackMax,Self,Term,X),X\==Term),(t2('=',_,StackMax,Self,Term,X),nop(X\==Term))). - - -t1('=',_,StackMax,Self,Term,X):- eval_args('=',_,StackMax,Self,Term,X). -t2('=',_,StackMax,Self,Term,X):- fail, subst_args('=',_,StackMax,Self,Term,X). -*/ - -%eval_H(Term,X):- if_or_else((subst_args(Term,X),X\==Term),(eval_args(Term,Y),Y\==Term)). - -print_goals(TermV):- write_src(TermV). - - -if_or_else(Goal,Else):- call(Goal)*->true;call(Else). - -interacting:- tracing,!. -interacting:- current_prolog_flag(debug,true),!. -interacting:- option_value(interactive,true),!. -interacting:- option_value(prolog,true),!. - -% call_max_time(+Goal, +MaxTime, +Else) -call_max_time(Goal,_MaxTime, Else) :- interacting,!, if_or_else(Goal,Else). -call_max_time(Goal,_MaxTime, Else) :- !, if_or_else(Goal,Else). -call_max_time(Goal, MaxTime, Else) :- - catch(if_or_else(call_with_time_limit(MaxTime, Goal),Else), time_limit_exceeded, Else). - - -catch_err(G,E,C):- catch(G,E,(always_rethrow(E)->(throw(E));C)). -dont_give_up(G):- catch(G,give_up(E),write_src_uo(dont_give_up(E))). - -not_in_eq(List, Element) :- - member(V, List), V == Element. - -:- ensure_loaded(metta_repl). - - -:- nodebug(metta(eval)). -:- nodebug(metta(exec)). -:- nodebug(metta(load)). -:- nodebug(metta(prolog)). -% Measures the execution time of a Prolog goal and displays the duration in seconds, -% milliseconds, or microseconds, depending on the execution time. -% -% Args: -% - Goal: The Prolog goal to be executed and timed. -% -% The predicate uses the `statistics/2` predicate to measure the CPU time before -% and after executing the provided goal. It calculates the elapsed time in seconds -% and converts it to milliseconds and microseconds. The output is formatted to -% provide clear timing information: -% -% - If the execution takes more than 2 seconds, it displays the time in seconds. -% - If the execution takes between 1 millisecond and 2 seconds, it displays the time -% in milliseconds. -% - If the execution takes less than 1 millisecond, it displays the time in microseconds. -% -% Example usage: -% ?- time_eval(my_goal(X)). -% -% ?- time_eval(sleep(0.95)). -% -% Output examples: -% ; Evaluation took 2.34 seconds. -% ; Evaluation took 123.45 ms. -% ; Evaluation took 0.012 ms. (12.33 microseconds) -% -time_eval(Goal):- time_eval('Evaluation',Goal). -time_eval(What,Goal) :- - timed_call(Goal,Seconds), - give_time(What,Seconds). - -ctime_eval(Goal):- ctime_eval('Evaluation',Goal). -ctime_eval(What,Goal) :- - ctimed_call(Goal,Seconds), - give_time(What,Seconds). - -wtime_eval(Goal):- wtime_eval('Evaluation',Goal). -wtime_eval(What,Goal) :- - wtimed_call(Goal,Seconds), - give_time(What,Seconds). - -%give_time(_What,_Seconds):- is_compatio,!. -give_time(What,Seconds):- - Milliseconds is Seconds * 1_000, - (Seconds > 2 - -> format('~N; ~w took ~2f seconds.~n~n', [What, Seconds]) - ; (Milliseconds >= 1 - -> format('~N; ~w took ~3f secs. (~2f milliseconds) ~n~n', [What, Seconds, Milliseconds]) - ;( Micro is Milliseconds * 1_000, - format('~N; ~w took ~6f secs. (~2f microseconds) ~n~n', [What, Seconds, Micro])))). - -timed_call(Goal,Seconds):- ctimed_call(Goal,Seconds). - -ctimed_call(Goal,Seconds):- - statistics(cputime, Start), - ( \+ rtrace_this(Goal)->rtrace_on_error(Goal);rtrace(Goal)), - statistics(cputime, End), - Seconds is End - Start. - -wtimed_call(Goal,Seconds):- - statistics(walltime, [Start,_]), - ( \+ rtrace_this(Goal)->rtrace_on_error(Goal);rtrace(Goal)), - statistics(walltime, [End,_]), - Seconds is (End - Start)/1000. - - -rtrace_this(eval_H(_, _, P , _)):- compound(P), !, rtrace_this(P). -rtrace_this([P|_]):- P == 'pragma!',!,fail. -rtrace_this([P|_]):- P == 'import!',!,fail. -rtrace_this([P|_]):- P == 'rtrace!',!. -rtrace_this(_Call):- option_value(rtrace,true),!. -rtrace_this(_Call):- is_debugging(rtrace),!. - -%:- nb_setval(cmt_override,lse('; ',' !(" ',' ") ')). - -:- abolish(fbug/1). -fbug(_):- is_compatio,!. -fbug(Info):- real_notrace(in_cmt(color_g_mesg('#2f2f2f',write_src(Info)))). -example0(_):- fail. -example1(a). example1(_):- fail. -example2(a). example2(b). example2(_):- fail. -example3(a). example3(b). example3(c). example3(_):- fail. -%eval_H(100,'&self',['change-state!','&var',[+,1,['get-state','&var']]],OUT) -%dcall(X):- (call(X),deterministic(YN)),trace,((YN==true)->!;true). -chkdet_call(XX):- !, call(XX). -chkdet_call0(XX):- !, call(XX). - -dcall0000000000(XX):- - USol = sol(dead), - copy_term_g(XX,X), - call_nth(USol,X,Nth,Det,Prev), - %fbug(call_nth(USol,X,Nth,Det,Prev)), - XX=Prev, - (Det==yes -> (!, (XX=Prev;XX=X)) ; - (((var(Nth) -> ( ! , Prev\==dead) ; - true), - (Nth==1 -> ! ; true)))). - -call_nth(USol,XX,Nth,Det,Prev):- - repeat, - ((call_nth(XX,Nth),deterministic(Det),arg(1,USol,Prev))*-> - ( nb_setarg(1,USol,XX)) - ; (!, arg(1,USol,Prev))). - -catch_red(Term):- catch_err(Term,E,pp_m(red,in(Term,E))). -%catch_red(Term):- call(Term). - -s2p(I,O):- sexpr_s2p(I,O),!. - -discover_head(Self,Load,Head):- - ignore(([Fn|PredDecl]=Head, - nop(( arg_types(PredDecl,[],EachArg), - metta_anew1(Load,metta_head(Self,Fn,EachArg)))))). - -discover_body(Self,Load,Body):- - nop(( [Fn|PredDecl] = Body, arg_types(PredDecl,[],EachArg), - metta_anew1(Load,metta_body(Self,Fn,EachArg)))). - -decl_length(TypeDecL,Len):- is_list(TypeDecL),!,length(TypeDecL,Len). -decl_length(_TypeDecL,1). - -arg_types([Ar|L],R,LR):- Ar == '->', !, arg_types(L,R,LR). -arg_types([[Ar|L]],R,LR):- Ar == '->', !, arg_types(L,R,LR). -arg_types(L,R,LR):- append(L,R,LR). - -%:- ensure_loaded('../../examples/factorial'). -%:- ensure_loaded('../../examples/fibonacci'). - -%print_preds_to_functs:-preds_to_functs_src(factorial_tail_basic) -ggtrace(G):- call(G). -ggtrace0(G):- ggtrace, - leash(-all), - visible(-all), - % debug, - %visible(+redo), - visible(+call), - visible(+exception), - maybe_leash(+exception), - setup_call_cleanup(trace,G,notrace). -:- dynamic(began_loon/1). -loon:- loon(typein). - - -catch_red_ignore(G):- if_or_else(catch_red(G),true). - -:- export(loon/1). -:- public(loon/1). - - -%loon(Why):- began_loon(Why),!,fbugio(begun_loon(Why)). -loon(Why):- is_compiling,!,fbug(compiling_loon(Why)),!. -%loon( _Y):- current_prolog_flag(os_argv,ArgV),member('-s',ArgV),!. -% Why\==toplevel,Why\==default, Why\==program,! -loon(Why):- is_compiled, Why\==toplevel,!,fbugio(compiled_loon(Why)),!. -loon(Why):- began_loon(_),!,fbugio(skip_loon(Why)). -loon(Why):- fbugio(began_loon(Why)), assert(began_loon(Why)), - do_loon. - -do_loon:- - ignore(( - \+ prolog_load_context(reloading,true), - maplist(catch_red_ignore,[ - - %if_t(is_compiled,ensure_mettalog_py), - install_readline_editline, - %nts1, - %install_ontology, - metta_final, - % ensure_corelib_types, - set_output_stream, - if_t(is_compiled,update_changed_files), - test_alarm, - run_cmd_args, - write_answer_output, - maybe_halt(7)]))),!. - -need_interaction:- \+ option_value('had_interaction',true), - \+ is_converting, \+ is_compiling, \+ is_pyswip,!, - option_value('prolog',false), option_value('repl',false), \+ metta_file(_Self,_Filename,_Directory). - -pre_halt1:- is_compiling,!,fail. -pre_halt1:- loonit_report,fail. -pre_halt2:- is_compiling,!,fail. -pre_halt2:- option_value('prolog',true),!,set_option_value('prolog',started),call_cleanup(prolog,pre_halt2). -pre_halt2:- option_value('repl',true),!,set_option_value('repl',started),call_cleanup(repl,pre_halt2). -pre_halt2:- need_interaction, set_option_value('had_interaction',true),call_cleanup(repl,pre_halt2). - -%loon:- time(loon_metta('./examples/compat/test_scripts/*.metta')),fail. -%loon:- repl, (option_value('halt',false)->true;halt(7)). -%maybe_halt(Seven):- option_value('prolog',true),!,call_cleanup(prolog,(set_option_value_interp('prolog',false),maybe_halt(Seven))). -%maybe_halt(Seven):- option_value('repl',true),!,call_cleanup(repl,(set_option_value_interp('repl',false),maybe_halt(Seven))). -%maybe_halt(Seven):- option_value('repl',true),!,halt(Seven). - -maybe_halt(_):- once(pre_halt1), fail. -maybe_halt(Seven):- option_value('repl',false),!,halt(Seven). -maybe_halt(Seven):- option_value('halt',true),!,halt(Seven). -maybe_halt(_):- once(pre_halt2), fail. -maybe_halt(Seven):- fbugio(maybe_halt(Seven)), fail. -maybe_halt(_):- current_prolog_flag(mettalog_rt,true),!. -maybe_halt(H):- halt(H). - - -:- initialization(nb_setval(cmt_override,lse('; ',' !(" ',' ") ')),restore). - - -%needs_repl:- \+ is_converting, \+ is_pyswip, \+ is_compiling, \+ has_file_arg. -% libswipl: ['./','-q',--home=/usr/local/lib/swipl] - -:- initialization(show_os_argv). - - -ensure_mettalog_system_compilable:- - %ensure_loaded(library(metta_python)), - ensure_mettalog_system. -ensure_mettalog_system:- - abolish(began_loon/1), - dynamic(began_loon/1), - system:use_module(library(quasi_quotations)), - system:use_module(library(hashtable)), - system:use_module(library(gensym)), - system:use_module(library(sort)), - system:use_module(library(writef)), - system:use_module(library(rbtrees)), - system:use_module(library(dicts)), - system:use_module(library(shell)), - system:use_module(library(edinburgh)), - % system:use_module(library(lists)), - system:use_module(library(statistics)), - system:use_module(library(nb_set)), - system:use_module(library(assoc)), - system:use_module(library(pairs)), - if_t(exists_source(library(swi_ide)),user:use_module(library(swi_ide))), - user:use_module(library(prolog_profile)), - %metta_python, - %ensure_loaded('./src/main/flybase_convert'), - %ensure_loaded('./src/main/flybase_main'), - %ensure_loaded(library(flybase_convert)), - %ensure_loaded(library(flybase_main)), - autoload_all, - make, - autoload_all, - %pack_install(predicate_streams, [upgrade(true),global(true)]), - %pack_install(logicmoo_utils, [upgrade(true),global(true)]), - %pack_install(dictoo, [upgrade(true),global(true)]), - !. - -file_save_name(E,_):- \+ symbol(E),!,fail. -file_save_name(E,Name):- file_base_name(E,BN),BN\==E,!,file_save_name(BN,Name). -file_save_name(E,E):- symbol_concat('Sav.',_,E),!. -file_save_name(E,E):- symbol_concat('Bin.',_,E),!. -before_underscore(E,N):-symbolic_list_concat([N|_],'_',E),!. -save_name(Name):- current_prolog_flag(os_argv,ArgV),member(E,ArgV),file_save_name(E,Name),!. -next_save_name(Name):- save_name(E), - before_underscore(E,N), - symbol_concat(N,'_',Stem), - gensym(Stem,Name), - \+ exists_file(Name), - Name\==E,!. -next_save_name(SavMeTTaLog):- option_value(exeout,SavMeTTaLog), - symbolic(SavMeTTaLog),atom_length(SavMeTTaLog,Len),Len>1,!. -next_save_name('Sav.MeTTaLog'). -qcompile_mettalog:- - ensure_mettalog_system, - option_value(exeout,Named), - catch_err(qsave_program(Named, - [class(development),autoload(true),goal(loon(goal)), - toplevel(loon(toplevel)), stand_alone(true)]),E,writeln(E)), - halt(0). -qsave_program:- ensure_mettalog_system, next_save_name(Name), - catch_err(qsave_program(Name, - [class(development),autoload(true),goal(loon(goal)), toplevel(loon(toplevel)), stand_alone(false)]),E,writeln(E)), - !. - - -:- ensure_loaded(library(flybase_main)). -:- ensure_loaded(metta_server). -:- initialization(update_changed_files,restore). - -nts :- nts1. -nts1:- !. % disable redefinition -nts1:- redefine_system_predicate(system:notrace/1), - %listing(system:notrace/1), - abolish(system:notrace/1), - dynamic(system:notrace/1), - meta_predicate(system:notrace(0)), - asserta((system:notrace(G):- (!,once(G)))). -nts1:- !. - -:- nts1. - -nts0:- redefine_system_predicate(system:notrace/0), - abolish(system:notrace/0), - asserta((system:notrace:- write_src_uo(notrace))). -%:- nts0. - -override_portray:- - forall( - clause(user:portray(List), Where:Body, Cl), - (assert(user:portray_prev(List):- Where:Body), - erase(Cl))), - asserta((user:portray(List) :- metta_portray(List))). - -metta_message_hook(A, B, C) :- - user: - ( B==error, - fbug(metta_message_hook(A, B, C)), - fail - ). - -override_message_hook:- - forall( - clause(user:message_hook(A,B,C), Where:Body, Cl), - (assert(user:message_hook(A,B,C):- Where:Body), erase(Cl))), - asserta((user:message_hook(A,B,C) :- metta_message_hook(A,B,C))). - -fix_message_hook:- - clause(message_hook(A, B, C), - user: - ( B==error, - fbug(user:message_hook(A, B, C)), - fail - ), Cl),erase(Cl). - -:- unnullify_output. - -%:- ensure_loaded(metta_python). - -%:- ensure_loaded('../../library/genome/flybase_loader'). - -:- ensure_loaded(metta_python). -:- ensure_loaded(metta_corelib). -%:- ensure_loaded(metta_help). - -:- enter_comment. -:- current_prolog_flag(stack_limit,X),X_16 is X * 16, set_prolog_flag(stack_limit,X_16). -:- initialization(use_corelib_file). -:- initialization(use_metta_ontology). - -immediate_ignore:- ignore((( - %write_src_uo(init_prog), - use_corelib_file, - (is_testing -> UNIT_TEST=true; UNIT_TEST=false), - set_is_unit_test(UNIT_TEST), - %trace, - \+ prolog_load_context(reloading,true), - initialization(loon(restore),restore), - % should fail (if tested from here https://swi-prolog.discourse.group/t/call-with-time-limit-2-not-enforcing-time-limit-as-expected/7755) - %test_alarm, - % nts1, - metta_final, - true))). - -use_metta_ontology:- ensure_loaded(library('metta_ontology.pfc.pl')). -% use_metta_ontology:- load_pfc_file('metta_ontology.pl.pfc'). -%:- use_metta_ontology. -%:- initialization(use_metta_ontology). -%:- initialization(loon(program),program). -%:- initialization(loon(default)). - -% Flush any pending output to ensure smooth runtime interactions -flush_metta_output :- - write_answer_output, ttyflush. - -% Write out answers in hyperon-experimental format to user_error -metta_runtime_write_answers(List) :- - with_output_to(user_error, (write('['), write_answers_aux(List), write(']'))). - -% Helper predicate to manage answer formatting to user_error -write_answers_aux([]) :- !. -write_answers_aux([H|T]) :- - with_output_to(user_error, (write_src_woi(H), (T == [] -> true ; write(', '), write_answers_aux(T)))). - -% Dynamically describe the current file or an actively reading file, providing context for runtime sessions -file_desc(Message) :- - prolog_load_context(file, CurrentFile), - ( stream_property(Stream, mode(read)), - stream_property(Stream, file_name(File)), - \+ at_end_of_stream(Stream), - File \= CurrentFile, - !, - sformat(Message, 'File(~w)', [File]) - ; sformat(Message, 'File(~w)', [CurrentFile]) - ). - -:- dynamic(runtime_session/4). - -% Begin a runtime session with detailed time recording, output to user_error -begin_metta_runtime :- - file_desc(Description), - current_times(WallStart, CPUStart), - asserta(runtime_session(start, WallStart, CPUStart, Description)), - with_output_to(user_error, format('~w started.~n', [Description])). - -% End a runtime session, calculate and print elapsed times, output to user_error -end_metta_runtime :- - file_desc(Description), - ( retract(runtime_session(start, WallStart, CPUStart, Description)) - -> calculate_elapsed_time(WallStart, CPUStart, WallElapsedTime, CPUElapsedTime), - print_elapsed_time(WallElapsedTime, CPUElapsedTime, Description) - ; with_output_to(user_error, format('Error: No runtime session start information found for "~w".~n', [Description])) - ). - -% Wall and CPU time -current_times(WallStart, CPUStart) :- - get_time(WallStart), - statistics(cputime, CPUStart). - -% Calculate elapsed times -calculate_elapsed_time(WallStart, CPUStart, WallElapsedTime, CPUElapsedTime) :- - current_times(WallEnd, CPUEnd), - WallElapsedTime is WallEnd - WallStart, - CPUElapsedTime is CPUEnd - CPUStart. - -% Print the elapsed wall and CPU time with a description, output to user_error -print_elapsed_time(WallElapsedTime, CPUElapsedTime, Description) :- - with_output_to(user_error, - format(' % Walltime: ~9f seconds, CPUtime: ~9f seconds for ~w~n', - [WallElapsedTime, CPUElapsedTime, Description])). - -% Execute a Prolog query and handle output, performance logging, and time measurements to user_error -do_metta_runtime(_Var,_Call) :- fast_option_value(compile, save),!. -do_metta_runtime( Var, Call) :- - functor(Call, Func, _), - atom_concat('Testing ', Func, Description), - current_times(WallStart, CPUStart), - % Execute the query and collect results - with_output_to(user_error, findall(Var, Call, List)), - % Record stop time - calculate_elapsed_time(WallStart, CPUStart, WallElapsedTime, CPUElapsedTime), - % Show results - with_output_to(user_error, metta_runtime_write_answers(List)), - % Print elapsed time - print_elapsed_time(WallElapsedTime, CPUElapsedTime, Description), - flush_metta_output. - - - -:- set_prolog_flag(metta_interp,ready). -%:- ensure_loaded(metta_runtime). -%:- set_prolog_flag(gc,false). - -:- use_module(library(clpr)). % Import the CLP(R) library -%:- initialization(loon_main, main). -:- initialization(loon(main), main). - -%:- ensure_loaded(mettalog('metta_ontology.pfc.pl')). - - -% Define a predicate to relate the likelihoods of three events -complex_relationship3_ex(Likelihood1, Likelihood2, Likelihood3) :- - { Likelihood1 = 0.3 * Likelihood2 }, - { Likelihood2 = 0.5 * Likelihood3 }, - { Likelihood3 < 1.0 }, - { Likelihood3 > 0.0 }. - -% Example query to find the likelihoods that satisfy the constraints -%?- complex_relationship(L1, L2, L3). - - - diff --git a/.Attic/metta_lang/metta_repl.pl.bak b/.Attic/metta_lang/metta_repl.pl.bak deleted file mode 100644 index dc4b5fd04b..0000000000 --- a/.Attic/metta_lang/metta_repl.pl.bak +++ /dev/null @@ -1,2304 +0,0 @@ -/* - * Project: MeTTaLog - A MeTTa to Prolog Transpiler/Interpreter - * Description: This file is part of the source code for a transpiler designed to convert - * MeTTa language programs into Prolog, utilizing the SWI-Prolog compiler for - * optimizing and transforming function/logic programs. It handles different - * logical constructs and performs conversions between functions and predicates. - * - * Author: Douglas R. Miles - * Contact: logicmoo@gmail.com / dmiles@logicmoo.org - * License: LGPL - * Repository: https://github.com/trueagi-io/metta-wam - * https://github.com/logicmoo/hyperon-wam - * Created Date: 8/23/2023 - * Last Modified: $LastChangedDate$ # You will replace this with Git automation - * - * Usage: This file is a part of the transpiler that transforms MeTTa programs into Prolog. For details - * on how to contribute or use this project, please refer to the repository README or the project documentation. - * - * Contribution: Contributions are welcome! For contributing guidelines, please check the CONTRIBUTING.md - * file in the repository. - * - * Notes: - * - Ensure you have SWI-Prolog installed and properly configured to use this transpiler. - * - This project is under active development, and we welcome feedback and contributions. - * - * Acknowledgments: Special thanks to all contributors and the open source community for their support and contributions. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the - * distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - - -%********************************************************************************************* -% PROGRAM FUNCTION: Implements a REPL (Read-Eval-Print Loop) for the Mettalog interpreter, providing -% interactive execution, debugging, and command handling capabilities. -%********************************************************************************************* - -% Ensure that the `metta_interp` library is loaded, -% That loads all the predicates called from this file -:- ensure_loaded(metta_interp). - -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -% IMPORTANT: DO NOT DELETE COMMENTED-OUT CODE AS IT MAY BE UN-COMMENTED AND USED -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - -% Directive to save history when the program halts. -:- at_halt(save_history). - -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -% You can debug mettalog using the repl: -% 1) enter "mettalog" on your command line -% 2) enter Prolog mode by entering "prolog." This gives you the '?-' swipl prompt. -% This method gives you a handy means of debugging. -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - -%! history_file_location(-Filename) is det. -% Determines the location of the REPL history file. -% On Linux, the history is stored in '~/.config/metta/repl_history.txt.' -% @arg Filename will be the expanded path to the history file. -% -% @example Retrieve the history file location: -% ?- history_file_location(Filename). -% Filename = '/home/user/.config/metta/repl_history.txt'. -% -history_file_location(Filename) :- - % Expands the relative path to an absolute path. - expand_file_name('~/.config/metta/repl_history.txt', [Filename]). - % For Linux, Windows paths might be different. - -%! check_directory_exists(+Dir) is det. -% Ensures that a directory exists. If not, it will create it. -% @arg Dir is the directory path to check. -% -% @example Ensure a directory exists: -% ?- check_directory_exists('/home/user/.config/metta'). -% true. -% -check_directory_exists(''). - % Base case for an empty string (root of directory tree). -check_directory_exists('/'). - % Base case for the root directory. -check_directory_exists('.'). - % Base case for the current directory. -check_directory_exists('~'). - % Base case for the home directory. -check_directory_exists('..'). - % Base case for the parent directory. -check_directory_exists(Dir) :- - % Get the parent directory of Dir. - file_directory_name(Dir, Parent), - % Recursively check and create parent directories if needed. - check_directory_exists(Parent), - % If the directory does not exist, create it. - (exists_directory(Dir) -> true ; make_directory(Dir)). - -%! check_file_exists_for_append(+HistoryFile) is det. -% Ensures that the history file exists and can be appended to. -% If the file does not exist, it will create the file and its directory. -% @arg HistoryFile is the path to the file to be checked or created. -% -% @example Ensure a history file exists: -% ?- check_file_exists_for_append('/home/user/.config/metta/repl_history.txt'). -% true. -% -check_file_exists_for_append(HistoryFile) :- - % Check if the file exists and is accessible for appending. - exists_file(HistoryFile), - access_file(HistoryFile, append), - !. -check_file_exists_for_append(HistoryFile) :- - % If the file does not exist, ensure the directory exists. - file_directory_name(HistoryFile, Dir), - check_directory_exists(Dir), - % Create the file by opening it in write mode. - open(HistoryFile, write, Stream, [create([read, write])]), - !, - % Close the stream after creating the file. - close(Stream). -check_file_exists_for_append(HistoryFile) :- - % If the file cannot be created, print an error message and halt the program. - write("Error opening history file: "), - writeln(HistoryFile), - halt(1). - -%! save_history is det. -% Saves the current input history to a file if input is from a terminal (tty). -% Uses el_write_history/2 to write the history. -% -% @example Save the current history: -% ?- save_history. -% true. -% -save_history :- - % Get the current input stream. - current_input(Input), - % Check if the input is from a terminal. - (stream_property(Input, tty(true)) -> - % If so, get the history file location and save the history. - (history_file_location(HistoryFile), - el_write_history(Input, HistoryFile)) - ; - % Otherwise, do nothing. - true). - -%! load_and_trim_history is det. -% Loads and trims the REPL history if needed, and installs readline support. -% -% @example Load and trim the history: -% ?- load_and_trim_history. -% true. -% -load_and_trim_history :- - % Disable tracing for the following operations. - notrace(( - % Get the current input stream. - current_input(In), - % Try installing readline, ignoring any errors. - ignore(install_readline(In)) - )). - -% Commented-out code related to REPL that is not currently in use. -% Previously: repl:- option_value('repl',prolog),!,prolog. - -% Previously: :- ensure_loaded(metta_toplevel). % Disabled for now, might be used in the future. - -% Previously: :- discontiguous do_metta_exec/3. -% This directive is commented out, indicating that discontiguous handling for the predicate `do_metta_exec/3` is not needed at the moment. - -% Previously: repl:- setup_call_cleanup(flag(repl_level,Was,Was+1),repl0, -% (flag(repl_level,_,Was),(Was==0 -> maybe_halt(7) ; true))). -% This version of the REPL setup using flags is commented out, probably replaced by simpler or alternative REPL logic. - -%! repl is det. -% Starts the REPL (Read-Eval-Print Loop) using `catch/3` to handle end-of-input gracefully. -% This ensures the REPL terminates without error when the end of input is reached. -% -% @example Start the REPL: -% ?- repl. -% metta> -% -repl :- - % Catch any end_of_input exception and terminate the REPL gracefully. - catch(repl2, end_of_input, true). - -%! repl1 is det. -% A higher-level REPL function that sets some options before starting the REPL process. -% It uses `with_option/3` to set internal flags and then invokes `repl2/0`. -% -% @example Start the REPL with internal options: -% ?- repl1. -% metta> -% -repl1 :- - % Set the option 'doing_repl' to true. - with_option('doing_repl', true, - % Set the 'repl' option to true and then start repl2. - with_option(repl, true, repl2)). - -%! repl2 is nondet. -% The main loop of the REPL, responsible for managing history, garbage collection, and catching any errors. -% It continually prompts the user until an error occurs or input is exhausted. -% -% @example Start the REPL loop: -% ?- repl2. -% metta> -% -repl2 :- - % Load the REPL history and clean it up if necessary. - load_and_trim_history, - % Begin an infinite loop using repeat to keep REPL active. - repeat, - % Reset internal caches for better performance. - reset_caches, - % Force garbage collection to free memory. - garbage_collect, - % Execute repl3 and catch any errors that occur during execution. - ignore(catch((ignore(catch(once(repl3), restart_reading, true))), - % If an error occurs, print the reason and continue the loop. - give_up(Why), pp_m(red, gave_up(Why)))), - % Fail at the end to ensure the repeat loop continues indefinitely. - fail. - -%! write_metta_prompt is det. -% Writes the REPL prompt for the user, including the current mode and self-reference. -% It uses the `flush_output/1` to ensure all output is displayed immediately. -% -% @example Display the REPL prompt: -% ?- write_metta_prompt. -% metta> -% -write_metta_prompt :- - % Ensure any pending output is flushed to the terminal. - flush_output(current_output), - % Write the initial prompt text "metta". - format('~Nmetta', []), - % Display the current REPL mode (e.g., normal, query). - current_read_mode(repl, Mode), write(Mode), - % Display the current self reference, unless it is '&self'. - current_self(Self), (Self == '&self' -> true ; write(Self)), - % Write the final '>' as the prompt and flush the output again. - write('>'), flush_output(current_output). - -%! repl3 is det. -% Prepares the REPL prompt and handles the user input in a safe way. -% It manages the prompt display and ensures the terminal is properly set up. -% -% @example Set up the REPL prompt and call repl4: -% ?- repl3. -% metta> -% -repl3 :- - % Create the prompt by writing it to an atom `P`. - with_output_to(atom(P), write_metta_prompt), - % Set up cleanup for the terminal prompt and execute repl4. - notrace(prompt(Was, P)), - setup_call_cleanup( - % Set the terminal prompt without tracing. - true, - % Flush the terminal and call repl4 to handle input. - ((ttyflush, repl4, ttyflush)), - % After execution, restore the previous terminal prompt. - notrace(prompt(_, Was))). - -%! repl4 is det. -% Executes the REPL logic by reading the input, processing expressions, and handling directives or commands. -% The loop is managed through exceptions (e.g., restarting or ending input). -% -% @example Execute the main REPL logic: -% ?- repl4. -% metta> -% -repl4 :- - % Reset the evaluation number to ensure expressions are counted properly. - ((reset_eval_num, - % Write the result of the previous evaluation (if any) to the output. - write_answer_output, - % The following command to reset terminal settings is commented out for now. - % ignore(shell('stty sane ; stty echo')), - % Read the next expression from the REPL input. - catch(repl_read(Expr),stream_error(_,E),(writeln(E),throw(restart_reading))), - % Check if the input is either `end_of_file` or empty on Windows; if so, throw `end_of_input`. - (if_t((Expr == end_of_file; (is_win64, Expr == '')), notrace(throw(end_of_input)))), - % Flush the terminal input/output to make sure the REPL is responsive. - ttyflush, - % Check for any directives embedded in the expression and process them. - (ignore(check_has_directive(Expr))), - % Get the current self reference and reading mode for the REPL. - current_self(Self), current_read_mode(repl, Mode), - % Output the read expression for debugging purposes, if applicable. - nop(writeqln(repl_read(Expr))),!, - % Evaluate the expression using the `do_metta/5` predicate. - ignore(once((do_metta(repl_true, Mode, Self, Expr, O)))),!, - % Optionally write the result of the evaluation to the source. - nop((write_src(O), nl)), - % Throw `restart_reading` to restart the REPL input process after execution. - nop(notrace(throw(restart_reading))))),!. - -%! check_has_directive(+V) is nondet. -% -% Processes a given input `V` to determine if it contains a recognized directive -% and executes the associated logic. This predicate handles several types of directives, -% such as switching modes, assigning values, or invoking debugging utilities. -% -% This predicate fails if the input `V` is a variable or if no matching directive is found. -% -% Directives can take several forms: -% - Simple commands like `'log.'` or `'rust.'` that switch modes. -% - Assignments of the form `call(N=V)`. -% - Special debugging and REPL controls using `@` or other characters. -% -% @arg V The input term to be checked and processed. This can be a variable, -% an atom, or a more complex term like an assignment. -% -% @example -% % Example of switching to mettalog mode: -% ?- check_has_directive('log.'). -% % This switches the system to the mettalog mode. -% -% % Example of switching to mettarust mode: -% ?- check_has_directive('rust.'). -% % This switches the system to the mettarust mode. -% -check_has_directive(V) :- var(V), !, fail. -% Directive to switch to mettalog. -check_has_directive('@log') :- switch_to_mettalog, !, write_src_uo(switch_to_mettalog),notrace(throw(restart_reading)). -% Directive to switch to mettarust. -check_has_directive('@rust') :- switch_to_mettarust, !, write_src_uo(switch_to_mettarust), notrace(throw(restart_reading)). -% Checks if the symbol contains a '.' (common for directives). -check_has_directive(Atom) :- symbol(Atom), symbol_concat(_, '.', Atom), !. -% Assign a value to a directive, e.g., call(N=V). -check_has_directive(call(N=V)) :- nonvar(N), !, set_directive(N, V). -% Enable rtrace debugging and restart reading. -check_has_directive(call(Rtrace)) :- rtrace == Rtrace, !, rtrace, notrace(throw(restart_reading)). -% Handle expressions in the form of N=V. -check_has_directive(NEV) :- symbol(NEV), symbolic_list_concat([N, V], '=', NEV), set_directive(N, V). -% Handle directive in the form [@Name, Value]. -check_has_directive([AtEq, Value]) :- symbol(AtEq), symbol_concat('@', Name, AtEq), set_directive(Name, Value). -% Handle mode changes in the REPL. -check_has_directive(ModeChar) :- symbol(ModeChar), metta_interp_mode(ModeChar, _Mode), !, set_directive(repl_mode, ModeChar). -% Displays options when '@' is input and restarts reading. -check_has_directive('@') :- do_show_options_values, !, notrace(throw(restart_reading)). -% Process expressions like @NEV=Value. -check_has_directive(AtEq) :- symbol(AtEq), symbol_concat('@', NEV, AtEq), option_value(NEV, Foo), fbug(NEV = Foo), !, notrace(throw(restart_reading)). -% No directive found. -check_has_directive(_). - -%! set_directive(+N, +V) is det. -% -% Assigns the value `V` to the directive `N`. Handles special cases such as -% REPL mode changes differently from general directives. -% -% @arg N The name of the directive to set. It can be a general option or -% a specific control like `mode`. -% @arg V The value to assign to the directive. -% -% @example -% % Set the REPL mode to 'debug': -% ?- set_directive('mode', 'debug'). -% -% % Assign a general option value: -% ?- set_directive('timeout', 100). -% -set_directive(N, V) :- symbol_concat('@', NN, N), !, set_directive(NN, V). -% Special case for setting the REPL mode. -set_directive(N, V) :- N == 'mode', !, set_directive(repl_mode, V). -% Set a general directive using `set_option_value_interp/2`. -set_directive(N, V) :- show_call(set_option_value_interp(N, V)), !, notrace(throw(restart_reading)). - -%! read_pending_white_codes(+In) is det. -% Reads the pending codes (whitespace characters) from the input stream `In`. -% Specifically, it looks for the newline character (ASCII 10). -% This predicate ensures that the REPL input stream is properly cleaned up. -% -% @arg In The input stream from which to read pending whitespace codes. -% -% @example -% % Clean up the input stream by reading pending newlines: -% ?- read_pending_white_codes(user_input). -% -read_pending_white_codes(In) :- - % Read pending codes from the input stream, only considering ASCII 10 (newline). - read_pending_codes(In, [10], []), - % Succeed after reading. - !. -% If the input stream is not provided, do nothing. -read_pending_white_codes(_). - -%! call_for_term_variables4v(+Term, +X, -Result, -NamedVarsList, +TF) is det. -% Handles the term `Term` and determines the term variable list and final result. -% This version handles the case when the term has no variables and converts it to a truth-functional form. -% -% @arg Term The input term to be analyzed. -% @arg X The list of variables found within the term. It can be empty or contain one variable. -% @arg Result The final result, either as the original term or transformed into a truth-functional form. -% @arg NamedVarsList The list of named variables associated with the term. -% @arg TF The truth-functional form when the term has no variables. -% -% @example -% % Example with no variables: -% ?- call_for_term_variables4v(foo, [], Result, Vars, true). -% Result = as_tf(foo, true), -% Vars = []. -% -call_for_term_variables4v(Term, [], as_tf(Term, TF), NamedVarsList, TF) :- - % Get global variable names for the term. - get_global_varnames(NamedVarsList), - % Succeed if no variables are present. - !. -% Handles the case when the term has one variable and passes the term as-is. -call_for_term_variables4v(Term, [X], Term, NamedVarsList, X) :- - % Get global variable names for the term. - get_global_varnames(NamedVarsList). - -%! balanced_parentheses(+Str) is semidet. -% Checks if parentheses are balanced in a string or list of characters `Str`. -% This version handles both string input and list input by converting the string to a list of characters. -% -% @arg Str A string or list of characters to check for balanced parentheses. -% -% @example -% ?- balanced_parentheses("(())"). -% true. -% -% ?- balanced_parentheses("(()"). -% false. -% -% ?- balanced_parentheses("text(with(parentheses))"). -% true. -% -balanced_parentheses(Str) :- - % If the input is a string, convert it to a list of characters. - string(Str), - string_chars(Str, Chars), - % Delegate to the list-based version. - !, balanced_parentheses(Chars, 0). -% If input is already a list of characters, check the balance starting at count 0. -balanced_parentheses(Chars) :- balanced_parentheses(Chars, 0). - -%! balanced_parentheses(+Chars, +N) is semidet. -% Recursive helper predicate to check if parentheses are balanced in a list of characters `Chars`. -% The second argument `N` keeps track of the net balance of opening and closing parentheses. -% -% @arg Chars A list of characters to process for balanced parentheses. -% @arg N A count tracking the net balance of open and close parentheses. -% -% @example -% ?- balanced_parentheses(['(', ')', '(', ')'], 0). -% true. -% -balanced_parentheses([], 0). -% Increment count when encountering an opening parenthesis. -balanced_parentheses(['('|T], N) :- N1 is N + 1, !, balanced_parentheses(T, N1). -% Decrement count when encountering a closing parenthesis, ensuring the count remains positive. -balanced_parentheses([')'|T], N) :- N > 0, N1 is N - 1, !, balanced_parentheses(T, N1). -% Skip any characters that are not parentheses. -balanced_parentheses([H|T], N) :- H \= '(', H \= ')', !, balanced_parentheses(T, N). - -%! next_expr(+ExprI, -Expr) is det. -% -% Processes the given expression and returns the next expression to be used. -% If `ExprI` is `end_of_file`, it attempts to retrieve a buffered comment or -% defaults to an empty string. Otherwise, it directly unifies `ExprI` with `Expr`. -% -% @arg ExprI The input expression, which may be `end_of_file`. -% @arg Expr The resulting expression to be used in further processing. -% -% @example -% % If ExprI is `end_of_file`, it tries to get a buffered comment or returns "". -% ?- next_expr(end_of_file, Expr). -% Expr = "". -% -next_expr(ExprI, Expr) :- - % If the input expression is `end_of_file`, handle it with a cut. - ExprI == end_of_file, !, - % Retrieve a buffered comment or default to an empty string. - (comment_buffer(Expr); (Expr = "")). -% If ExprI is not `end_of_file`, unify it directly with Expr. -next_expr(ExprI, Expr) :- ExprI = Expr. - -%! repl_read(+In, -Expr) is det. -% -% Reads an expression from the given input stream, processes it with -% `next_expr/2`, and returns the result. -% -% @arg In The input stream from which the expression is read. -% @arg Expr The resulting expression after reading and processing. -% -% @example -% % Open a file and read an expression from it. -% ?- open('input.txt', read, In), repl_read(In, Expr). -% Expr = some_expression. -% -repl_read(In, Expr) :- - % Read the next expression from the input stream. - repl_read_next(In, ExprI), - % Process it to determine the final expression. - next_expr(ExprI, Expr). - -%! repl_read(-Expr) is det. -% -% Reads an expression without a specific input stream, processes it with -% `next_expr/2`, and returns the result. -% -% @arg Expr The resulting expression after reading and processing. -% -% @example -% % Read an expression from the default input source. -% ?- repl_read(Expr). -% Expr = some_expression. -% -repl_read(Expr) :- - % Read the next expression. - repl_read_next(ExprI), - % Process it to determine the final expression. - next_expr(ExprI, Expr). - -% maybe Write any stored comments to the output? -%! comment_buffer(-Comment) is nondet. -% -% Retrieves and removes a comment from the metta file comment buffer. -% It retracts a `metta_file_comment/5` fact and unifies its `Comment` field -% with the output argument. -% -% @arg Comment The comment retrieved from the buffer. -% -% @example -% % Assume a comment was previously stored in the buffer. -% ?- comment_buffer(Comment). -% Comment = 'This is a comment'. -% -comment_buffer(Comment) :- - % Retract a comment from the buffer and unify it with the output argument. - retract(metta_file_comment(_Line, _Col, _CharPos, Comment, _Pos)). - -%! repl_read_next(+NewAccumulated, -Expr) is det. -% -% Reads the next expression by interpreting the accumulated input. It handles -% special cases (such as symbols `'!'` and `'+'`), manages syntax errors, -% balances parentheses, and normalizes spaces in input. If an error occurs, -% the reading process may be restarted. -% -% @arg NewAccumulated The accumulated input to be processed. -% @arg Expr The resulting expression, or a specific symbol or mode indicator. -% -% @example -% % Read a valid metta expression from input. -% ?- repl_read_next("write(hello)", Expr). -% Expr = call(write(hello)). -% -repl_read_next(NewAccumulated, Expr) :- - % Concatenate the input with '.' and try to interpret it as an atom. - symbol_concat(Atom,'.',NewAccumulated), - % Attempt to read the term from the atom, handle errors and retry if necessary. - catch_err((read_term_from_atom(Atom, Term, []), Expr = call(Term)), E, - (((fail, write('Syntax error: '), writeq(E), nl, repl_read_next(Expr))))), !. - -% Previously commented: repl_read_next(Str, Expr):- ((clause(t_l:s_reader_info(Expr),_,Ref),erase(Ref))). - -% Handle special case for '!' symbol. -repl_read_next("!", '!') :- !. -% Handle special case for '+' symbol. -repl_read_next("+", '+') :- !. -% Convert a string to an atom and check for a valid interpreter mode. -repl_read_next(Str, Atom) :- atom_string(Atom, Str), metta_interp_mode(Atom, _), !. - -% Handle input starting with '@'. -repl_read_next(Str, Expr) :- symbol_concat('@', _, Str), !, atom_string(Expr, Str). -% Handle incorrect input with unbalanced parentheses. -repl_read_next(Str, _Expr) :- symbol_concat(')', _, Str), !, fbug(repl_read_syntax(Str)), throw(restart_reading). - -% Normalize spaces in the accumulated input and re-read if the normalized result is different. -repl_read_next(NewAccumulated, Expr) :- fail, - normalize_space(string(Renew), NewAccumulated), - Renew \== NewAccumulated, !, - repl_read_next(Renew, Expr). - -% Previously commented: repl_read_next(Str, 'add-atom'('&self',Expr)):- symbol_concat('+',W,Str),!,repl_read_next(W,Expr). -% Previously commented: repl_read_next(NewAccumulated, exec(Expr)):- string_concat("!", Renew, NewAccumulated), !, repl_read_next(Renew, Expr). - -% Read and process the input if parentheses are balanced, then add it to the history. -repl_read_next(NewAccumulated, Expr) :- - % Normalize the string - normalize_space(string(Renew), NewAccumulated), - % Convert the accumulated string to a list of characters. - string_chars(Renew, Chars), - % Check if the parentheses are balanced. - balanced_parentheses(Chars), - % Ensure there is some content in the input. - length(Chars, Len), Len > 0, - % Parse the metta expression from the accumulated input. - catch(read_metta(Renew, Expr),stream_error(_,_),fail),!, - add_history_string(Renew). - -% Read the next line of input, accumulate it, and continue processing. -repl_read_next(Accumulated, Expr) :- - % Read a line from the current input stream. - read_line_to_string(current_input, Line), - % Call repl_read_next with the new line concatenated to the accumulated input. - repl_read_next(Accumulated, Line, Expr). - -%! repl_read_next(+Accumulated, +Line, -Expr) is det. -% -% Handles reading input, including special cases such as end-of-file. -% Accumulates lines of input and processes them to form valid expressions. -% It gracefully manages EOF, concatenates input, and continues reading. -% -% @arg Accumulated The accumulated input so far. -% @arg Line The new line to be added to the accumulated input. -% @arg Expr The resulting expression or an indication of end-of-file. -% -% @example -% % Handle end-of-file input gracefully. -% ?- repl_read_next(_, end_of_file, Expr). -% Expr = end_of_file. -% -repl_read_next(_, end_of_file, end_of_file) :- nop(writeln("")), notrace(throw(end_of_input)). - -% Continue reading if no input has been accumulated yet. -% repl_read_next(Accumulated, "", Expr) :- !, repl_read_next(Accumulated, Expr). -% Handle end-of-file as a valid input. -repl_read_next(_Accumulated, Line, Expr) :- Line == end_of_file, !, Expr = Line. - -% Concatenate accumulated input with the new line and continue reading. -repl_read_next(Accumulated, Line, Expr) :- - % Concatenate the accumulated input with the new line using a space between them. - symbolics_to_string([Accumulated, "\n", Line], NewAccumulated), !, - % Continue reading and processing the new accumulated input. - repl_read_next(NewAccumulated, Expr). - -% Retrieve stored reader info and erase it. -repl_read_next(O2) :- clause(t_l:s_reader_info(O2), _, Ref), erase(Ref). - -% Repeat the REPL reading process until input is fully processed. -repl_read_next(Expr) :- - repeat, - % Remove any pending buffer codes. - remove_pending_buffer_codes(_, Was), - % Convert buffer contents to a string. - text_to_string(Was, Str), - % Read the expression from the input. - repl_read_next(Str, Expr), - % Stop the repeat loop if there are no more pending codes. - ((peek_pending_codes(_, Peek), Peek == []) -> ! ; true). - -%! add_history_string(+Str) is det. -% -% Adds a string to the REPL history if the input is coming from a terminal (TTY). -% This helps maintain a history of inputs, which can be useful for interactive -% sessions. -% -% If the input stream is not from a terminal, the predicate simply succeeds without -% taking any action. -% -% @arg Str The string to be added to the REPL history. -% -% @example Adding a string to history: -% ?- add_history_string("example query"). -% true. -% -add_history_string(Str) :- - % Check if the current input stream is from a terminal (tty). - current_input(Input), - % If the input is from a terminal, add Str to the history using el_add_history/2. - (((stream_property(Input, tty(true)))) -> - ((notrace(ignore(el_add_history(Input,Str))))) - ; - % Otherwise, do nothing. - true), !. - -%! add_history_src(+Exec) is det. -% Adds the source code to the input history if the execution is non-empty. -% @arg Exec is the executed code to be added to the history. -% -% @example Add executed code to history: -% ?- add_history_src([write('Hello'), nl]). -% true. -% -% @example No effect with empty code: -% ?- add_history_src([]). -% true. -% -add_history_src(Exec) :- - % Check if Exec is not empty, and if so, write it to the string H and add it to the history. - notrace(ignore((Exec \= [], with_output_to(string(H), with_indents(false, write_src(Exec))), add_history_string(H)))). - -%! add_history_pl(+Exec) is det. -% -% Adds evaluated terms to the REPL history unless they are variables or special cases. -% -% @arg Exec The evaluated term to be added to the history. -% -% @example Add a regular term to history: -% ?- add_history_pl(write('Hello')). -% true. -% -% @example Skip variables: -% ?- add_history_pl(_). -% true. -% -add_history_pl(Exec) :- - % If Exec is a variable, do nothing. - var(Exec), !. - -% Recursive case to handle adding nested evaluated terms to history. -add_history_pl(eval(_,catch_red(PL),_)) :- - % If the term is in catch_red, process the nested PL term. - !, add_history_pl(PL). - -% If the evaluated term is a failure, recursively handle the nested term. -add_history_pl(show_failure(PL)) :- - % Process failure cases by adding the nested PL term. - !, add_history_pl(PL). - -% If the term is in as_tf form, recursively handle the nested term. -add_history_pl(as_tf(PL,_OUT)) :- - % Process as_tf terms by adding the nested PL term. - !, add_history_pl(PL). - -% General case for adding non-variable, non-special terms to the history. -add_history_pl(Exec) :- - % Write the executed term to the string H, then add it to the history. - notrace(ignore((Exec \= [], with_output_to(string(H), with_indents(false, (writeq(Exec), writeln('.')))), add_history_string(H)))). - -% Directive to set a global variable for variable names. -:- nb_setval(variable_names, []). - -%! call_for_term_variables5(+Term, +DC, +Vars1, +Vars2, -CallTerm, -DCVars, -TF) is det. -% -% Processes term variables and generates a call structure based on the provided term, -% handling cases with ground terms, single variables, and multiple variables. -% -% @arg Term The input term to process. -% @arg DC The direct constraints or variables list (can be empty). -% @arg Vars1 The first set of variables (e.g., `[Var=Value]` format). -% @arg Vars2 The second set of variables. -% @arg CallTerm The generated term call (e.g., `call_nth/2` or `as_tf/2`). -% @arg DCVars The combined list of variables or constraints. -% @arg TF The variable or value associated with the call. -% -% @example Handling a ground term: -% ?- call_for_term_variables5(hello, [], [], [], CallTerm, DCVars, TF). -% CallTerm = as_tf(hello, TF), -% DCVars = [], -% TF = _. -% -% @example Single variable case: -% ?- call_for_term_variables5(hello, [], [], [X=_], CallTerm, DCVars, TF). -% CallTerm = call_nth(hello, Count), -% DCVars = ['Count' = Count], -% TF = X. -% - % If the term is ground, return the as_tf form. -call_for_term_variables5(Term,[],[],[],as_tf(Term,TF),[],TF) :- ground(Term), !. - % If the term is ground, create a call_nth with the term. -call_for_term_variables5(Term,DC,[],[],call_nth(Term,TF),DC,TF) :- ground(Term), !. -% If there is one variable, set the term to call_nth. -call_for_term_variables5(Term,_,[],[_=Var],call_nth(Term,Count),['Count'=Count],Var). -% Similar case when the variable is reversed in arguments. -call_for_term_variables5(Term,_,[_=Var],[],call_nth(Term,Count),['Count'=Count],Var). -% If both term variables and equal variable are present, pass them along. -call_for_term_variables5(Term,_,Vars,[_=Var],Term,Vars,Var). -% Same case but with the variables reversed. -call_for_term_variables5(Term,_,[_=Var],Vars,Term,Vars,Var). -% Handle case with more than one variable, generating a call_nth. -call_for_term_variables5(Term,_,SVars,Vars,call_nth(Term,Count),[Vars,SVars],Count). - -%! is_interactive(+From) is nondet. -% -% Checks if the input source is interactive, such as the REPL or a terminal. -% This predicate delegates the check to an internal helper `is_interactive0/1`. -% -% @arg From The source to check, typically an input stream or context. -% -% @example Check if the source is interactive: -% ?- is_interactive(user_input). -% true. -% -% @example Handling non-interactive sources: -% ?- open('file.pl', read, In), is_interactive(In), close(In). -% false. -% -% Delegate to the internal helper predicate. -is_interactive(From) :- notrace(is_interactive0(From)). - -%! is_interactive0(+From) is nondet. -% -% Internal helper to determine if the given input source is interactive. -% This predicate checks various cases, including symbolic streams, explicit flags, -% and properties of streams to decide whether the input is interactive (e.g., REPL). -% -% @arg From The source to evaluate, which could be a symbolic name, stream, or flag. -% -% @example Check if a symbolic source is interactive: -% ?- is_interactive0(repl_true). -% true. -% -is_interactive0(From) :- compound(From), From = file(_), !, fail. -is_interactive0(From) :- - % Check if the source is repl_true, meaning it is interactive. - From == repl_true, !. -is_interactive0(From) :- - % If the source is false, it is not interactive. - From == false, !, fail. -is_interactive0(From) :- - % Check if the source is symbolic and a stream that does not have a filename. - symbolic(From), is_stream(From), !, \+ stream_property(From, filename(_)). -is_interactive0(From) :- - % If the source is true, it is interactive. - From = true, !. - -% ================================================== -% Predicate to check and process assertions within terms. -% ================================================== - -%! inside_assert(+Var, -Result) is det. -% -% Processes and identifies terms that involve assertions, extracting relevant information. -% This predicate recursively navigates through various term structures to determine if -% the term contains an assertion or related construct. -% -% @arg Var The input term or variable to be analyzed. -% @arg Result The processed result, potentially modified based on the term structure. -% -% @example -% % Process a term containing an assertion. -% ?- inside_assert(assert(foo), Result). -% Result = assert(foo). -% -inside_assert(Var,Var) :- - % If the variable is not a compound term, leave it unchanged. - \+ compound(Var), !. -inside_assert([H,IA,_],IA) :- - % Check if the term is symbolic and starts with 'assert'. - symbol(H), symbol_concat('assert', _, H), !. -inside_assert(Conz,Conz) :- - % Check if the term is considered a 'conz' (constant). - is_conz(Conz), !. -inside_assert(exec(I),O) :- - % If the term is exec, recursively process the inside assertion. - !, inside_assert(I,O). -inside_assert(Eval,O) :- - % If the term is an evaluation, extract the relevant part and process it. - functor(Eval, eval_H, A), A1 is A - 1, arg(A1, Eval, I), !, inside_assert(I, O). -inside_assert(call(I),O) :- - % Handle call terms by processing the inside assertion. - !, inside_assert(I, O). -inside_assert(?-(I),O) :- - % Handle query terms by processing the inside assertion. - !, inside_assert(I, O). -inside_assert(:-(I),O) :- - % Handle clause terms by processing the inside assertion. - !, inside_assert(I, O). - % Default case where the variable is unchanged. -inside_assert(Var,Var). - -% ================================================== -% Predicate to retrieve the current reading mode (REPL or file). -% ================================================== - -%! current_read_mode(+Source, -Mode) is det. -% -% Retrieves the current reading mode based on the source, which can either be -% the REPL or a file. It checks the relevant settings and options to determine -% the mode, defaulting to `'+'` if no specific mode is set. -% -% @arg Source The source of the input, either `repl` or `file`. -% @arg Mode The mode retrieved, or `'+'` if no specific mode is set. -% -% @example -% % Retrieve the REPL mode, defaulting to '+' if unset. -% ?- current_read_mode(repl, Mode). -% Mode = '+'. -% -current_read_mode(repl,Mode) :- - % Retrieve the REPL mode from the options if set, otherwise default to '+'. - ((option_value(repl_mode, Mode), Mode \== []) -> true; Mode = '+'), !. -current_read_mode(file,Mode) :- - % Retrieve the file mode from nb_current if set, otherwise default to '+'. - ((nb_current(file_mode, Mode), Mode \== []) -> true; Mode = '+'). - -%! eval(+Form) is det. -% Evaluates a Form and ensures all conditions in the form hold true. -% Handles the case where the form is wrapped in `all/1`. -% @arg Form is the form to be evaluated. -% -% @example -% % Evaluate a form wrapped in `all/1`. -% ?- eval(all(write(hello))). -% hello -% true. -% -eval(all(Form)) :- - % Check that Form is instantiated (nonvar) and evaluate it as long as it is true. - nonvar(Form), !, forall(eval(Form),true). -% Evaluate a form by calling do_metta/5 with the current Self context and display the output. -eval(Form) :- - % Get the current self-reference. - current_self(Self), - % Execute the form and generate the output using do_metta/5. - do_metta(true, exec, Self, Form, Out), - % Write the result to the source. - output_language(metta_answers, write_src(Out)). - -%! eval(+Form, -Out) is det. -% Evaluates a form and returns the output. -% @arg Form is the input form to evaluate. -% @arg Out is the output after evaluation. -% -% @example -% % Evaluate a form and retrieve the output. -% ?- eval(write(hello), Out). -% Out = some_output. -% -eval(Form, Out) :- - % Get the current self-reference. - current_self(Self), - % Call eval/3 to evaluate the form and generate the output. - eval(Self, Form, Out). - -%! eval(+Self, +Form, -Out) is det. -% Internal evaluation helper that evaluates a form with a timeout. -% @arg Self is the current self-reference. -% @arg Form is the input form to evaluate. -% @arg Out is the output after evaluation. -% -% @example -% % Evaluate a form with the current self-reference and retrieve the output. -% ?- current_self(Self), eval(Self, write(hello), Out). -% Out = some_output. -% -eval(Self, Form, Out) :- - % Use eval_H with a timeout of 500 to evaluate the form. - eval_H(500, Self, Form, Out). - -%! eval_I(+Self, +Form, -OOut) is det. -% Evaluates a form and transforms the output using xform_out/2. -% @arg Self is the current self-reference. -% @arg Form is the form to evaluate. -% @arg OOut is the transformed output. -% -% @example -% % Evaluate a form and transform the output. -% ?- current_self(Self), eval_I(Self, write(hello), OOut). -% OOut = some_output. -% -eval_I(Self, Form, OOut) :- - % Evaluate the form with a timeout using eval_H. - eval_H(500, Self, Form, Out), - % Enable trace for debugging purposes. - trace, - % Transform the output. - xform_out(Out, OOut). - -%! xform_out(+Out, -OOut) is det. -% Transforms the output by checking if it is a return value. -% @arg Out is the initial output. -% @arg OOut is the transformed output. -% -% @example -% % Transform a returned value. -% ?- xform_out(return_value, OOut). -% OOut = return_value. -% -% % Handle a non-return value. -% ?- xform_out(some_output, OOut). -% OOut = 'Empty'. -% -xform_out(Out, OOut) :- - % If the output is a returned value, pass it through unchanged. - is_returned(Out), !, OOut = Out. -% If the output is not a return value, set OOut to 'Empty'. -xform_out(_Out, 'Empty'). - -%! name_vars(+Equality) is det. -% Assigns names to variables in the given term. -% @arg P is the term containing variables to be named. -name_vars(Equality) :- - % Ignore failures when naming variables. - ignore(name_vars0(Equality)). - -%! name_vars0(+Equality) is det. -% Helper predicate that assigns names to variables if necessary. -% @arg Equality is a term containing variables. -% -% @example -% % Assign names to variables in an equality expression. -% ?- name_vars(X=Y). -% true. -% -name_vars0(X=Y) :- - % If X and Y are identical, do nothing. - X == Y, !. -% If X is a '$VAR', set the name. -name_vars0(X='$VAR'(X)). - -%! reset_cache is det. -% Resets internal caches. -% Placeholder for cache resetting logic. -reset_cache. - -%! reset_caches is det. -% Resets all caches by evaluating each clause that defines reset_cache. -reset_caches :- - % For each clause of reset_cache, run the body in rtrace mode to handle errors. - forall(clause(reset_cache, Body), forall(rtrace_on_error(Body), true)). - -%! interactively_do_metta_exec(+From, +Self, +TermV, +Term, +X, +NamedVarsList, +Was, -Output, -FOut) is det. -% Executes a metta command interactively, handling potential errors and caching. -% Resets caches and evaluates the execution command, catching any errors that occur. -% -% @arg From is the source of the interaction (e.g., REPL, file). -% @arg Self is the current context or environment. -% @arg TermV is the evaluated version of the term. -% @arg Term is the term to be executed. -% @arg X is a variable placeholder. -% @arg NamedVarsList is the list of variable names used in the execution. -% @arg Was is the previous state before execution. -% @arg Output is the output generated from the execution. -% @arg FOut is the final output, after additional processing. -% -% @example -% ?- interactively_do_metta_exec(repl, self, TermV, my_term, X, NamedVarsList, Was, Output, FOut). -% Output = ..., FOut = ... -interactively_do_metta_exec(From,Self,TermV,Term,X,NamedVarsList,Was,Output,FOut) :- - % Reset internal caches before executing the command. - reset_caches, - % Attempt to execute the command interactively, catching any errors. - catch(interactively_do_metta_exec00(From,Self,TermV,Term,X,NamedVarsList,Was,Output,FOut), - Error, - % If an error occurs, log it along with the source and the term. - write_src(error(Error,From,TermV))). - -each_pair_list(A-B,A,B). - -%! interactively_do_metta_exec00(+From, +Self, +TermV, +Term, +X, +NamedVarsList, +Was, -Output, -FOut) is det. -% A helper function that handles the core logic of the interactive metta execution, catching potential aborts. -% This is the next layer in the call stack after interactively_do_metta_exec/9. -% -% @arg From is the source of the interaction. -% @arg Self is the current context or environment. -% @arg TermV is the evaluated version of the term. -% @arg Term is the term to be executed. -% @arg X is a variable placeholder. -% @arg NamedVarsList is the list of variable names used in the execution. -% @arg Was is the previous state before execution. -% @arg Output is the output generated from the execution. -% @arg FOut is the final output, after additional processing. -interactively_do_metta_exec00(file(lsp(From)),Self,TermV,Term,X,NamedVarsList,Was,OutputL,FOutL):- fail, nonvar(From), !, - findall(Output-FOut,interactively_do_metta_exec01(repl_true,Self,TermV,Term,X,NamedVarsList,Was,Output,FOut),List), - maplist(each_pair_list,List,OutputL,FOutL). - -interactively_do_metta_exec00(From,Self,TermV,Term,X,NamedVarsList,Was,Output,FOut) :- - % Attempt the actual execution and catch any '$aborted' exceptions. - catch(interactively_do_metta_exec01(From,Self,TermV,Term,X,NamedVarsList,Was,Output,FOut), - % Handle the '$aborted' exception by logging it. - '$aborted', fbug(aborted(From,TermV))). - -%! interactively_do_metta_exec01(+From, +Self, +_TermV, +Term, -X, +NamedVarsList, +Was, -VOutput, +FOut) is det. -% -% Executes a term in a controlled interactive environment, handling history, skipping, and timing of results. -% This predicate manages evaluation in an interactive session, possibly skipping certain executions based on file source and other conditions. -% -% @arg From is the source of the input (file, repl, etc.). -% @arg Self is the context for evaluation. -% @arg _TermV is the evaluated term (unused here). -% @arg Term is the term to be evaluated. -% @arg X is the output/result of the evaluation. -% @arg NamedVarsList is a list of variable bindings. -% @arg Was is a flag indicating whether interaction occurred. -% @arg VOutput is the variable holding the formatted output. -% @arg FOut is the final output to be printed. -% -% @example -% ?- interactively_do_metta_exec01(file("example"), self, _, term(likes), Result, NamedVarsList, Was, Output, Final). -% Result = likes(X,Y), -% Output = "Execution Time: 1.5s", -% Final = 'Completed Successfully'. -% -% @see reset_eval_num/0 for resetting evaluation counters, notrace/1 to suppress trace during execution, and lazy_findall/3 for lazy evaluation. - -% Handles interactive execution of mettalog commands, but skips execution if From is a file and results are hidden. -interactively_do_metta_exec01(file(_), Self, _TermV, Term, X, _NamedVarsList, _Was, _Output, _FOut) :- - % Checks if the term should hide results when sourced from a file - file_hides_results(Term), !, - % Evaluate arguments and return the result - eval_args(Self, Term, X). - -% Reset evaluation counter -interactively_do_metta_exec01(From,Self,_TermV,Term,X,NamedVarsList,Was,VOutput,FOut):- - %format("%%%%%%%%%%%%%%%%%%%%%%%%%2 ~w\n",[Term]), - notrace(( - - % Reset evaluation counters for a fresh start - reset_eval_num, - - % Initialize the result variable, with FOut to hold the final output - Result = res(FOut), - - % Placeholder for a previous result, starting with 'Empty' - Prev = prev_result('Empty'), - - % Assert the current term into a base evaluation - inside_assert(Term,BaseEval), - - % If compatible, determine the evaluation mode (either 'leap' or 'each') - (is_compatio -> option_else(answer,Leap,leap) ; option_else(answer,Leap,each)), - - % Set options for maximum and initial result counts, infinite results if needed - option_else('maximum-result-count',MaxResults,inf), - option_else('initial-result-count',LeashResults,10), - - % Control variable initialized with max result count and leap control - Control = contrl(MaxResults,Leap), - Skipping = _, - - % Commented code for interactive control, previously enabled for file skipping - /* previously: if From = file(_Filename), option_value('exec',skip), \+ always_exec(BaseEval) */ - (((From = file(_Filename), option_value('exec',skip), \+ always_exec(BaseEval))) - -> ( - % Skip execution if conditions are met - GgGgGgGgGgG = (skip(Term),deterministic(Complete)), - % Mark as skipped - Skipping = 1,!, - % Previously: Output = "Skipped" - /* previously: color_g_mesg('#da70d6', (write('% SKIPPING: '), writeq(eval_H(500,Self,BaseEval,X)),writeln('.'))) */ - true - ) - ; % Otherwise, execute the goal interactively - GgGgGgGgGgG = ( - % Execute Term and capture the result - (( (Term),deterministic(Complete), - % Transform output for display and store it in the result - xform_out(VOutput,Output), nb_setarg(1,Result,Output)))), - !, % Ensure the top-level metta evaluation is completed - - % Reset result number flag - flag(result_num,_,0), - - % Prepare evaluation for the base term - PL=eval(Self,BaseEval,X), - - % Apply mappings and assignments, track result history if necessary - ( % with_indents(true, - \+ \+ (user:maplist(name_vars,NamedVarsList), - user:name_vars('OUT'=X), - /* previously: add_history_src(exec(BaseEval)) */ - if_t(Skipping==1,writeln(' ; SKIPPING')), - /* previously: if_t(TermV\=BaseEval,color_g_mesg('#fa90f6', (write('; '), with_indents(false,write_src(exec(BaseEval)))))) */ - - % Handle interactive result output or non-interactive result history - if_t((is_interactive(From);Skipping==1), - ( - if_t( \+ option_value(doing_repl,true), - if_t( \+ option_value(repl,true), - if_t( option_value(prolog,true), add_history_pl(PL)))), - if_t(option_value(repl,true), add_history_src(exec(BaseEval))))), - - % Debug output in interactive mode, showing evaluated terms and results - prolog_only((color_g_mesg('#da70d6', (write('% DEBUG: '), writeq(PL),writeln('.'))))), - true))))), - - % Print formatted answer output - in_answer_io(format('~N[')),!, - - % Interactive looping with possible timing and stepping control - (forall_interactive( - From, WasInteractive,Complete, %may_rtrace - (timed_call(GgGgGgGgGgG,Seconds)), - ((((((Complete==true->!;true), - %repeat, - set_option_value(interactive,WasInteractive), - Control = contrl(Max,DoLeap), - nb_setarg(1,Result,Output), - current_input(CI), - read_pending_codes(CI,_,[]), - flag(result_num,R,R+1), - flag(result_num,ResNum,ResNum), - reset_eval_num, - %not_compatio(format('~N')), maybe more space between answers? - - user_io(( - in_answer_io(if_t((Prev\=@=prev_result('Empty')),write(', '))), - nb_setarg(1,Prev,Output))), - - - output_language(answers,(if_t(ResNum=(old_not_compatio(format('~N~nDeterministic: ', [])), !); %or Nondet - /* previously: handle deterministic result output */ - (Complete==true -> (old_not_compatio(format('~N~nLast Result(~w): ',[ResNum])),! ); - old_not_compatio(format('~N~nNDet Result(~w): ',[ResNum]))))), - ignore((( - if_t( \+ symbolic(Output), not_compatio(nop(nl))), - %if_t(ResNum==1,in_answer_io(format('~N['))), - % user_io - (with_indents(is_mettalog, - color_g_mesg_ok(yellow, - \+ \+ - (maybe_name_vars(NamedVarsList), - old_not_compatio(write_bsrc(Output)), - true)))) )) ))))), - in_answer_io(write_asrc((Output))), - - not_compatio(extra_answer_padding(format('~N'))), % Just in case, add some virt space between answers - - ((Complete \== true, WasInteractive, DoLeap \== leap, - LeashResults > ResNum, ResNum < Max) -> Stepping = true ; Stepping = false), - - %if_debugging(time,with_output_to(user_error,give_time('Execution',Seconds))), - if_t((Stepping==true;Complete==true),if_trace(time,color_g_mesg_ok(yellow,(user_io(give_time('Execution',Seconds)))))), - %with_output_to(user_error,give_time('Execution',Seconds)), - %user_io(give_time('Execution',Seconds)), - %not_compatio(give_time('Execution',Seconds), - color_g_mesg(green, - ignore((NamedVarsList \=@= Was ->(not_compatio(( - reverse(NamedVarsList,NamedVarsListR), - maplist(print_var,NamedVarsListR), nop(nl)))) ; true))))), - ( - (Stepping==true) -> - (old_not_compatio(write("~npress ';' for more solutions ")),get_single_char_key(C), - old_not_compatio((writeq(key=C),nl)), - (C=='b' -> (once(repl),fail) ; - (C=='m' -> make ; - (C=='t' -> (nop(set_debug(eval,true)),rtrace) ; - (C=='T' -> (set_debug(eval,true)); - (C==';' -> true ; - (C==esc('[A',[27,91,65]) -> nb_setarg(2, Control, leap) ; - (C=='L' -> nb_setarg(1, Control, ResNum) ; - (C=='l' -> nb_setarg(2, Control, leap) ; - (((C=='\n');(C=='\r')) -> (!,fail); - (!,fail)))))))))))); - - (Complete\==true, \+ WasInteractive, Control = contrl(Max,leap)) -> true ; - (((Complete==true ->! ; true))))), not_compatio(extra_answer_padding(format('~N~n'))))) - *-> (ignore(Result = res(FOut)),ignore(Output = (FOut))) - ; (flag(result_num,ResNum,ResNum),(ResNum==0-> - (in_answer_io(nop(write('['))),old_not_compatio(format('~N~n~n')),!,true);true))), - in_answer_io(write(']\n')), - ignore(Result = res(FOut)). - -old_not_compatio(G):- call(G),ttyflush. - -%! maybe_assign(+N_V) is det. -% -% Attempts to assign variable V to the variable name N, if V is unbound. -% -% @arg N=V is the variable assignment term. -% -% @example -% % Attempt to assign a variable name. -% ?- maybe_assign(x=Var). -% Var = '$VAR'(x). -% -maybe_assign(N=V):- ignore(V='$VAR'(N)). - -% Disable the debug mode for the 'metta(time)' predicate. -:- nodebug(metta(time)). - -%! mqd is det. -% -% A query executor that retrieves terms from a knowledge base using 'query-info', computes variable intersections, -% and evaluates the query Q against the term T in the context of a flybase. -% -% @example -% % Execute the query matching process. -% ?- mqd. -% Entity1 -% Entity2 -% ... -% true. -% -mqd :- - % Iterate over all metta_atom/3 calls that match the 'query-info' term. - forall(metta_atom(_KB, ['query-info', E, T, Q]), - (writeln(E), % Print the entity E. - term_variables(T, TVs), % Get the variables of the term T. - term_variables(Q, QVs), % Get the variables of the query Q. - intersection(TVs, QVs, _, _, SVs), % Compute the intersection of the variables of T and Q. - notrace(eval(['match', '&flybase', Q, T], SVs)))). % Evaluate the matching terms. - -%! get_single_char_key(-O) is det. -% -% Reads a single character from input and transforms it into an atom. -% Handles escape sequences for special keys. -% -% @arg O is the output character, transformed into an atom. -% -% @example -% % Read a single character and transform it into an atom. -% ?- get_single_char_key(O). -% O = a. -% -get_single_char_key(O):- - % Get the single character input. - get_single_char(C), - % Recursively read characters until a valid key is obtained. - get_single_char_key(C, O). - -%! get_single_char_key(+C, -A) is det. -% -% Handles special cases such as escape sequences for the arrow keys. -% -% @arg C is the character received. -% @arg A is the resulting atom. -% -% @example -% % Handle escape sequence input. -% ?- get_single_char_key(27, esc(A, [27|Codes])). -% A = '\e[A', Codes = [91, 65]. -% -get_single_char_key(27, esc(A,[27|O])):- - !, - % Read pending escape sequences and convert them to a name. - current_input(Input), - read_pending_codes(Input, O, []), - name(A, O). -% Convert the character code C into an atom A. -get_single_char_key(C, A):- name(A, [C]). - -%! forall_interactive(+From, +WasInteractive, +Complete, :Goal, :After) is det. -% -% Executes a goal in interactive or non-interactive contexts based on the source (From). -% It handles stepping, completion, and quiet execution of post-goal actions. -% -% @arg From is the source of the execution (e.g., file, prolog, REPL). -% @arg WasInteractive is a flag indicating whether the execution was interactive. -% @arg Complete indicates whether the goal reached a final result. -% @arg Goal is the main goal to be executed interactively. -% @arg After is the action to perform after the goal is executed. -forall_interactive(file(_), false, Complete, Goal, After) :- - !, - % Execute the goal. - %format("%%%%%%%%%%%%%%%%%%%%%%%%%0 ~w\n",[Goal]), - Goal, - % If the goal is complete, execute 'After', otherwise skip it. - (Complete == true -> (After, !) ; (\+ After)). -forall_interactive(prolog, false, Complete, Goal, After) :- - !, - % Execute the goal. - %format("%%%%%%%%%%%%%%%%%%%%%%%%%1 ~w\n",[Goal]), - Goal, - % If the goal is complete, succeed, otherwise continue. - (Complete == true -> ! ; true), - % Execute 'After' quietly (without trace output). - quietly(After). -forall_interactive(From, WasInteractive, Complete, Goal, After) :- - % Check if the source (From) is interactive. - (is_interactive(From) -> WasInteractive = true ; WasInteractive = false), - !, - % Execute the goal. - Goal, - % If the goal is complete, quietly execute 'After', otherwise negate 'After'. - (Complete == true -> (quietly(After), !) ; (quietly(\+ After))). - -%! print_var(+Name, +Var) is det. -% -% Prints a variable name and its value. -% -% @arg Name is the name of the variable. -% @arg Var is the value of the variable. -% -% @example Example of printing a variable: -% ?- print_var(X, 42). -% X = 42. -print_var(Name=Var) :- print_var(Name,Var). - -%! write_var(+V) is det. -% -% Writes a variable, handling special cases like unbound or '$VAR'. -% -% @arg V is the variable to be written. -% -% @example -% % Write an unbound variable. -% ?- write_var(X). -% _G123 -% -write_var(V):- var(V), !, write_dvar(V),!. % Write the unbound variable using a helper predicate. -write_var('$VAR'(S)):- !, write_dvar(S),!. % Handle the Prolog internal variable representation. -write_var(V):- write_dvar(V),!. % Default case: write the variable. - -%! print_var(+Name, +Var) is det. -% -% Prints a variable assignment in the format `Name = Var`. -% -% @arg Name The name of the variable. -% @arg Var The value of the variable. -% -% @example -% % Print a variable assignment. -% ?- print_var(Name, 42). -% Name = 42 -% -print_var(Name,Var):- - % Print the variable name. - write_var(Name), - % Print the equality sign. - write(' = '), - % Print the source of the variable value. - write_bsrc(Var), - % Print a newline after the variable. - nl. - -%! write_asrc(+Var) is det. -% -% Writes a variable, skipping if it is 'Empty' and compatible with the environment. -% -% @arg Var is the variable to be written. -% -% @example -% % Write a variable unless it is 'Empty' in a compatible environment. -% ?- write_asrc(X). -% -write_asrc(Var):- Var=='Empty',is_compatio,!. % Skip writing if the variable is 'Empty' in a compatible mode. -write_asrc(Var):- write_bsrc(Var),!. % Otherwise, write the variable. - -%! write_bsrc(+Var) is det. -% -% Writes the value of a variable, handling ground terms and variables with goals. -% -% @arg Var is the variable to be written. -% -% @example -% % Write the value of a ground term. -% ?- write_bsrc(42). -% 42 -% -write_bsrc(Var):- Var=='Empty',!,write(Var). % Special case: write 'Empty' directly. -write_bsrc(Var):- ground(Var),!,write_bsrc1(Var). % If the variable is ground, write it directly. -write_bsrc(Var):- copy_term(Var,Copy,Goals),Var=Copy,write_bsrc_goal(Var,Goals). % For non-ground terms, handle goals. - -%! write_bsrc_goal(+Var, +Goals) is det. -% -% Writes a variable along with its associated goals, if any. -% -% @arg Var The variable to be written. -% @arg Goals A list of goals associated with the variable. -% -% @example -% % Write a variable with goals. -% ?- write_bsrc_goal(Var, [goal1, goal2]). -% Var { goal1 goal2 } -% -write_bsrc_goal(Var,[]):- write_src(Var). % Write the variable if no goals are present. -write_bsrc_goal(Var,[G|Goals]):- - % Write the variable. - write_bsrc1(Var), - % Write the opening brace for goals. - write(' { '), - % Write the first goal. - write_bsrc1(G), - % Write the remaining goals, separated by spaces. - maplist(write_src_space, Goals), - % Write the closing brace and newline. - writeln(' } '). - -%! write_bsrc1(+Var) is det. -% -% Writes the value of a variable (often not indenting it) -% -% @arg Var is the variable to be written. -% -% @example -% % Write a list of lists. -% ?- write_bsrc1([[1, 2], [3, 4]]). -% [[1,2],[3,4]] -% -write_bsrc1(Var):- is_list(Var), member(E, Var), is_list(E), !, write_src(Var). -write_bsrc1(Var):- write_src_woi(Var). - -%! write_src_space(+Goal) is det. -% -% Writes a goal with a preceding space. -% -% @arg Goal is the goal to be written. -% -% @example -% % Write a goal with a space before it. -% ?- write_src_space(goal1). -% goal1 -% -write_src_space(Goal):- - % Write a space before the goal. - write(' '), - % Write the goal. - write_bsrc1(Goal). - -%! get_term_variables(+Term, -DontCaresN, -CSingletonsN, -CNonSingletonsN) is det. -% -% Collects variables from a Prolog term, identifying do-not-care variables, singletons, and non-singletons. -% It then maps these variables into named variable lists. -% -% @arg Term is the Prolog term whose variables are being analyzed. -% @arg DontCaresN is the list of do-not-care variables (those represented by underscores). -% @arg CSingletonsN is the list of singleton variables (those that appear only once). -% @arg CNonSingletonsN is the list of non-singleton variables (those that appear more than once). -% -% @example Analyze the variables in a term: -% ?- get_term_variables(foo(X, _Y, X), DontCares, Singletons, NonSingletons). -% DontCares = [_Y], Singletons = [X], NonSingletons = []. -get_term_variables(Term, DontCaresN, CSingletonsN, CNonSingletonsN) :- - % Extract all variables from the term. - term_variables(Term, AllVars), - % Get the global variable names. - get_global_varnames(VNs), - % Log the extracted variables and global variable names. - writeqln(term_variables(Term, AllVars)=VNs), - % Identify singleton variables in the term. - term_singletons(Term, Singletons), - % Identify do-not-care variables in the term. - term_dont_cares(Term, DontCares), - % Filter out singletons from the set of all variables. - include(not_in_eq(Singletons), AllVars, NonSingletons), - % Remove do-not-care variables from the non-singleton set. - include(not_in_eq(DontCares), NonSingletons, CNonSingletons), - % Remove do-not-care variables from the singleton set. - include(not_in_eq(DontCares), Singletons, CSingletons), - % Map the do-not-care, singleton, and non-singleton variables into named variable lists. - maplist(into_named_vars, [DontCares, CSingletons, CNonSingletons], - [DontCaresN, CSingletonsN, CNonSingletonsN]), - % Log the final result. - writeqln([DontCaresN, CSingletonsN, CNonSingletonsN]). - - -%! term_dont_cares(+Term, -DontCares) is det. -% -% Finds the do-not-care variables (those represented by underscores) in a term. -% -% @arg Term is the term to analyze. -% @arg DontCares is the list of do-not-care variables in the term. -% -% @example -% % Find do-not-care variables in a term. -% ?- term_dont_cares(f(_, X, _), DontCares). -% DontCares = [_G123, _G124]. -% -term_dont_cares(Term, DontCares) :- - % Extract all variables from the term. - term_variables(Term, AllVars), - % Get global variable names. - get_global_varnames(VNs), - % Find variables that have sub-variables in the term. - include(has_sub_var(AllVars), VNs, HVNs), - % Filter out underscore variables (do-not-cares). - include(underscore_vars, HVNs, DontCareNs), - % Extract the actual variable values from the named variables. - maplist(arg(2), DontCareNs, DontCares). - -%! into_named_vars(+Vars, -L) is det. -% -% Converts a list of variables into a list of named variables. -% -% @arg Vars is the input list of variables or a term containing variables. -% @arg L is the resulting list of named variables. -% -% @example -% ?- into_named_vars([X,Y,Z], L). -% L = ['X'=X, 'Y'=Y, 'Z'=Z]. -into_named_vars(Vars,L):- - % If Vars is a list, process each variable individually. - is_list(Vars), !, - % Map each variable to its named version using name_for_var_vn/2. - maplist(name_for_var_vn,Vars,L). -into_named_vars(Vars,L):- - % If Vars is a term, extract the variables using term_variables/2. - term_variables(Vars,VVs),!, - % Convert extracted variables into named variables. - into_named_vars(VVs,L). - - -%! has_sub_var(+AllVars, +Equality) is nondet. -% -% Succeeds if V is a sub-variable of any of the variables in AllVars. -% -% @arg AllVars is the list of variables to search in. -% @arg Equality is the variable to check as a sub-variable. -% -% @example -% % Check if a variable is a sub-variable of another. -% ?- has_sub_var([X, Y], X=Z). -% true. -% -has_sub_var(AllVars,_=V):- - % Check if V is a sub-variable of any variable in AllVars. - sub_var(V,AllVars). - - -%! underscore_vars(+Var) is nondet. -% -% Succeeds if the variable or name represents a do-not-care variable (underscore). -% -% @arg Var is the variable or name to check. -% -% @example -% % Check if a variable is a do-not-care variable. -% ?- underscore_vars('_G123'). -% true. -% -underscore_vars(V):- - % If V is a variable, retrieve its name and check if it is an underscore variable. - var(V),!, - name_for_var(V,N),!, - underscore_vars(N). -underscore_vars(N=_):- - % If N is a symbolic value, further check if it starts with an underscore. - !, symbolic(N),!, - underscore_vars(N). -underscore_vars(N):- - % If N is a symbolic value, check if it starts with an underscore. - symbolic(N),!, - symbol_concat('_',_,N). - - -%! get_global_varnames(-VNs) is det. -% -% Retrieves the global list of variable names. -% -% @arg VNs is the list of variable names in the current context. -% -% @example -% % Retrieve the global variable names. -% ?- get_global_varnames(VNs). -% VNs = [X, Y]. -% -get_global_varnames(VNs):- - % If there are variable names in nb_current, use them. - nb_current('variable_names',VNs),VNs\==[],!. -get_global_varnames(VNs):- - % Otherwise, retrieve variable names from the current Prolog context. - prolog_load_context(variable_names,VNs),!. - - -%! maybe_set_var_names(+List) is det. -% -% Conditionally sets the variable names if the list is not empty. -% -% @arg List is the list of variable names. -% -% @example -% % Set a list of variable names if it is non-empty. -% ?- maybe_set_var_names([X, Y]). -% true. -% -maybe_set_var_names(List):- - % If the list is empty, do nothing. - List==[],!. -maybe_set_var_names(List):- - % If the list is non-empty, set the list of variable names. - is_list(List),!, - nb_linkval(variable_names,List). -maybe_set_var_names(_). - - -%! name_for_var_vn(+V, -EqualityPair) is det. -% -% Maps a variable V to a named variable pair N=V. -% -% @arg V is the input variable. -% @arg EqualityPair is the resulting named variable pair. -% -% @example -% % Map a variable to its named pair. -% ?- X = some_value, name_for_var_vn(X, Pair). -% Pair = N = some_value. -% -name_for_var_vn(V,N=V):- - % Retrieve the name for the variable V. - name_for_var(V,N). - - -%! name_for_var(+V, -N) is det. -% -% Retrieves the name for a variable V based on the current variable names. -% -% @arg V is the variable whose name is being retrieved. -% @arg N is the name corresponding to V. -% -% @example -% % Retrieve the name for a variable from global names. -% ?- nb_linkval(variable_names, ['X'=X]), name_for_var(X, N). -% N = 'X'. -% -name_for_var(V,N):- - % If V is a variable, check the global variable names. - var(V),!, - get_global_varnames(VNs), - member(N=VV,VNs), - VV==V,!. -name_for_var(N=_,N):- !. -name_for_var(V,N):- - % Convert the variable V to an atom representing its name. - term_to_atom(V,N),!. - -%! really_trace is nondet. -% -% Activates tracing if 'exec' or 'eval' tracing options are enabled, or if debugging is enabled for exec or eval. -% Used as a helper to conditionally invoke tracing logic. -% -% @example Example usage: -% ?- really_trace. -% Trace mode will be activated if conditions match. -really_trace :- - % Check if 'exec' or 'eval' tracing options are set, or if debugging is active. - once(option_value('exec', rtrace); option_value('eval', rtrace); is_debugging((exec)); is_debugging((eval))). - -% Ensures that tracing is enabled before running the goal. -may_rtrace(Goal):- - % If tracing is required, call really_rtrace/1. - really_trace, !, really_rtrace(Goal). -% Otherwise, enable tracing temporarily for the goal and execute it. -may_rtrace(Goal):- - Goal *-> true; ( \+ tracing, trace, really_rtrace(Goal)). - -% Actual tracing logic that checks for transpiling and invokes the goal with tracing. -really_rtrace(Goal):- - % If transpiling, call rtrace/1 on the goal. - is_transpiling, !, rtrace(call(Goal)). -% Otherwise, run the goal with debug contexts for exec and eval. -really_rtrace(Goal):- - with_debug((e), with_debug((exec), Goal)). - - -%! rtrace_on_existence_error(:G) is nondet. -% -% Attempts to execute the goal G, but if an existence error is encountered, it switches to tracing and retries G. -% -% @arg G is the goal to execute. -% -% @example -% % Demonstrate retrying a goal on existence error with tracing. -% ?- rtrace_on_existence_error(nonexistent_predicate). -% ERROR: existence_error ... -% -rtrace_on_existence_error(G):- - % Catch any existence errors, log them, and retry G with tracing enabled. - !, catch_err(G, E, (fbug(E = G), \+ tracing, trace, rtrace(G))). - - -%! prolog_only(:Goal) is nondet. -% -% Runs the goal if tracing is enabled for Prolog operations. -% -% @arg Goal is the Prolog goal to execute. -% -% @example -% % Run a goal only if Prolog tracing is enabled. -% ?- prolog_only(write('Tracing enabled for Prolog')). -% Tracing enabled for Prolog -% -prolog_only(Goal):- - % If Prolog tracing is enabled, run the goal. - if_trace(prolog, Goal). - - -%! write_compiled_exec(+Exec, +Goal) is det. -% -% Compiles the goal for execution and prints the compiled result. -% -% @arg Exec is the compiled execution result. -% @arg Goal is the goal being compiled and executed. -% -% @example -% % Compile and print the result of a goal. -% ?- write_compiled_exec(Result, my_goal). -% #114411: answer2(Result) :- my_goal -% -write_compiled_exec(Exec, Goal):- - % Compile the goal for execution and store the result in Res. - compile_for_exec(Res, Exec, Goal), - % Print the compiled goal with formatting. - Call = do_metta_runtime(Res, Goal), - output_language(prolog, notrace((color_g_mesg('#114411', print_pl_source(:- Call))))), - call(Call). - - -%! verbose_unify(+Term) is det. -% -% Activates verbose unification mode for variables in the given term. If no -% specific trace context is provided, it defaults to 'trace'. -% -% @arg Term The term whose variables will be traced. -% -% @example -% % Enable verbose unification on a term. -% ?- verbose_unify(X + Y). -% true. -% -verbose_unify(Term) :- - % Default to 'trace' context for verbose unification. - verbose_unify(trace, Term). - -%! verbose_unify(+What, +Term) is det. -% -% Activates verbose unification mode for variables in the term with the specified context. -% -% @arg What The trace context for verbose unification. -% @arg Term The term whose variables will be traced. -% -% @example -% % Enable verbose unification with a custom context. -% ?- verbose_unify(my_trace, X + Y). -% true. -% -verbose_unify(What, Term) :- - % Extract variables from the term and apply `verbose_unify0` to each. - term_variables(Term, Vars), - maplist(verbose_unify0(What), Vars), - !. - -%! verbose_unify0(+What, +Var) is det. -% -% Applies verbose unification to individual variables by assigning the `verbose_unify` attribute. -% -% @arg What The trace context for verbose unification. -% @arg Var The variable to which the attribute will be assigned. -% -% @example -% % Assign the 'verbose_unify' attribute to a variable. -% ?- verbose_unify0(trace, X). -% true. -% -verbose_unify0(What, Var) :- - % Set the 'verbose_unify' attribute for the variable. - put_attr(Var, verbose_unify, What). - -% Attribute unification hook for verbose_unify, logs when variables are unified. -verbose_unify:attr_unify_hook(Attr, Value) :- - % Log the unification process for the attribute and value. - format('~N~q~n', [verbose_unify:attr_unify_hook(Attr, Value)]), - % Perform verbose unification. - vu(Attr, Value). - -%! vu(+Attr, +Value) is det. -% -% Handles different verbose unification cases based on the attributes provided. -% -% @arg Attr is the attribute that determines the unification behavior. -% @arg Value is the value to unify. -% -% @example Example usage: -% -% ?- vu(trace, _). -% % Starts the trace. -% -% ?- vu(fail, _). -% % Fails the unification. -% -vu(_Attr, Value):- - % Skip if the value is a frozen variable (ftVar). - is_ftVar(Value), - !. -vu(fail, _Value):- - % Fail the unification if the attribute is 'fail'. - !, fail. -vu(true, _Value):- - % Succeed silently if the attribute is 'true'. - !. -vu(trace, _Value):- - % Enable tracing if the attribute is 'trace'. - trace. - -%! toplevel_goal(+Goal) is det. -% -% Entry point for executing a goal with variable tracing disabled. -% -% @arg Goal is the goal to be executed. -% -% @example -% ?- toplevel_goal(likes(A,B)). -% Solution: A = alice, B = bob. -% - -% Entry point for a goal execution, tracing is turned off by default. -toplevel_goal(Goal) :- - % Extract variables from the goal. - term_variables(Goal,Vars), - % Pass the goal and its variables to the interactive loop. - interact(Vars, Goal, trace_off). - - -%! trace_goal(+Goal) is det. -%! trace_goal(+Goal, +Tracing) is det. -% -% Entry point for executing a goal with tracing enabled or disabled. -% -% @arg Goal is the goal to be executed. -% @arg Tracing is either trace_on or trace_off to control tracing behavior. -% -% @example -% ?- trace_goal(likes(A,B)). -% Entering goal: likes(A,B) -% Solution: A = alice, B = bob. -% - -% Entry point for executing a goal with tracing enabled by default. -trace_goal(Goal) :- - % By default, tracing is enabled. - trace_goal(Goal, trace_on). - -% Execute a goal with optional tracing. -trace_goal(Goal, Tracing) :- - % If tracing is on, print the goal being entered. - (Tracing == trace_on -> writeln('Entering goal:'), writeln(Goal) ; true), - % Extract variables from the goal. - term_variables(Goal, Variables), - % Call the goal. - (call(Goal) -> - % If the goal succeeds, print the result and interact with the user if tracing is on. - (Tracing == trace_on -> writeln('Goal succeeded with:'), writeln(Variables) ; true), - interact(Variables, Goal, Tracing) - ; % If the goal fails, log the failure if tracing is on. - (Tracing == trace_on -> writeln('Goal failed.') ; true), - false - ). - - -%! interact(+Variables, +Goal, +Tracing) is det. -% -% Handles interaction with the user, allowing them to request the next solution or execute commands. -% -% @arg Variables is the list of variables bound by the goal. -% @arg Goal is the goal currently being executed. -% @arg Tracing is the trace state (on or off). -% -% @example -% ?- interact([A, B], likes(A, B), trace_on). -% Solution: A = alice, B = bob. -% [;next]? -% - -% This predicate handles user interaction and command processing during execution. -interact(Variables, Goal, Tracing) :- - % Call the goal and print the result. - call(Goal), write('Solution: '), write_src(Variables), - % Prompt the user to continue or stop. - write(' [;next]?'), - % Get a single character input from the user. - get_single_char(Code), - % If the input is a valid command, process it. - (command(Code, Command) -> - handle_command(Command, Variables, Goal, Tracing) - ; % If the input is unknown, print an error and continue interaction. - writeln('Unknown command.'), interact(Variables, Goal, Tracing) % Handle unknown commands. - ). - -%! install_readline_editline is det. -% -% Installs readline or editline support for the current input stream, enabling advanced input handling. -% -% @example Example usage: -% -% ?- install_readline_editline. -% -% This installs readline/editline support, allowing for line editing and history during input. -:- dynamic(is_installed_readline_editline/1). -:- volatile(is_installed_readline_editline/1). -install_readline_editline :- - % Get the current input stream. - current_input(Input), - % Install readline support for the current input. - install_readline(Input), - !. - -%! el_wrap_metta(+Input) is det. -% -% Wraps the input stream in editline (or readline) for use with mettalog, if it is a TTY (terminal). -% -% @arg Input is the input stream to be wrapped. -% -% @example Example usage: -% -% ?- el_wrap_metta(user_input). -% -% This wraps the user input stream, enabling line editing and history for interactive inputs. -% -% Note: This setup is specific to the mettalog environment and does not use the default SWI-Prolog completions. -% -% @see editline:el_wrap/4 for more details on wrapping input streams in editline. -el_wrap_metta(Input) :- - % If the input is already wrapped, do nothing. - el_wrapped(Input), - !. -el_wrap_metta(Input) :- - % Check if the input is from a terminal (tty). - stream_property(Input, tty(true)), - !, - % Wrap the input stream using editline with specific configurations for swipl. - editline:el_wrap(swipl, Input, user_output, user_error), - % Add custom commands specific to mettalog environment. - add_metta_commands(Input), - % Ensure that editline is properly set up for the input stream. - forall(editline:el_setup(Input), true). -el_wrap_metta(_NoTTY) :- - % Do nothing for non-tty clients (e.g., SWISH or HTTP/REST-based input). - true. - -%! add_metta_commands(+Input) is det. -% -% Sets up command bindings in the terminal for metta operations, adding useful key commands for editing. -% The predicate uses editline predicates to bind input commands for electric matching, history search, etc. -% -% @arg Input is the terminal input stream for which commands are being bound. -% -% This function ensures that useful key bindings, like electric matching for parentheses and history searching, are added to the current input. -% File completions are commented out for potential future use. -% -/* previously: It would be nice to include file name completion here, but it was skipped for atom completion */ -add_metta_commands(Input) :- - % TODO: File name completion would be useful, but it is currently skipped for Prolog atom completion. - % Bind a function for atom and file completion. Commented out. - % editline:el_addfn(Input,complete,'Complete atoms and files',editline:complete), - % Bind a function to list completions. Also commented out. - % editline:el_addfn(Input,show_completions,'List completions',editline:show_completions), - % Bind the electric function to highlight matching brackets during input. - editline:el_addfn(Input, electric, 'Indicate matching bracket', editline:electric), - % Bind the incremental search function to allow searching through input history. - editline:el_addfn(Input, isearch_history, 'Incremental search in history', editline:isearch_history), - % Previously bound commands for tab completion and listing completions, commented out for now. - % editline:el_bind(Input,["^I",complete]), - % editline:el_bind(Input,["^[?",show_completions]), - % Bind the "^R" key to initiate an incremental search through history. - editline:el_bind(Input, ["^R", isearch_history]), - % Enable the electric mode for the current input. - editline:bind_electric(Input), - % Source additional commands from the input (if any are defined). - editline:el_source(Input, _). - -%! install_readline(+Input) is det. -% -% Installs readline functionality for the input stream, providing useful editing commands and history. -% This predicate configures the Prolog input stream to support terminal history and command completion using the editline library. -% -% @arg Input is the input stream for which readline features should be installed. -% -% This version skips installation for non-tty(true) clients (e.g., SWISH or HTTP clients). -% -% @example Example of usage: -% -% ?- install_readline(user_input). -% -install_readline(Input):- - % Check if readline is already installed for this Input. - is_installed_readline_editline(Input), !. -% previously: Compatibility check for non-standard environments. Skipped for now. -%install_readline(_):- is_compatio, !. -install_readline(Input):- - % Check if Input is a terminal (tty). - stream_property(Input, tty(true)), - % Assert that readline is now installed for this Input. - assert(is_installed_readline_editline(Input)), - % Install editline functionality (main logic for readline). - install_readline_editline1, - % Use the editline library (previously: readline library is commented out). - %use_module(library(readline)), - use_module(library(editline)), - % Catch potential errors when loading history (currently ignored). - %nop(catch(load_history,_,true)), - % Unwrap the Prolog input wrapper, so that the custom readline features can be used. - ignore(el_unwrap(Input)), - % Wrap the input with the Metta readline handler. - ignore(el_wrap_metta(Input)), - % Load command history from a file, if it exists. - history_file_location(HistoryFile), - % Check if the history file exists, ensuring we can append to it. - check_file_exists_for_append(HistoryFile), - % Load the previous history from the file into the readline session. - el_read_history(Input, HistoryFile), - % previously: Adding specific history commands for convenience, now skipped. - %add_history_string("!(load-flybase-full)"), - %add_history_string("!(pfb3)"), - %add_history_string("!(obo-alt-id $X BS:00063)"), - %add_history_string("!(and (total-rows $T TR$) (unique-values $T2 $Col $TR))"), - !. - -% Clause to handle non-tty(true) clients, like SWISH or HTTP server requests. -install_readline(_NoTTY). % For non-tty(true) clients over SWISH/Http/Rest server - -%! install_readline_editline1 is det. -% -% Ensures readline is properly installed using the editline library, but only runs once. -% This setup prevents redundant installations and simplifies configuration for terminal input. -% -% @example Example of usage: -% -% ?- install_readline_editline1. -% -% This predicate will execute once to install readline, preventing multiple installations. -% -:- dynamic setup_done/0. -:- volatile setup_done/0. - -% If setup_done is already asserted, skip the rest of the predicate. -install_readline_editline1 :- - setup_done, % Check if setup has already been done. - !. % Cut to prevent further execution if setup_done is true. - -% If setup_done is not true, assert it and continue with the installation process. -install_readline_editline1 :- - asserta(setup_done). % Assert that setup is now complete. - -% previously: Various other initialization tasks were included here, but they have been commented out as overkill. -% '$toplevel':( -% '$clean_history', % Clear command history. -% apple_setup_app, % Initialize Apple-specific application setup. -% '$run_initialization', % Run system initialization tasks. -% '$load_system_init_file', % Load system initialization files. -% set_toplevel, % Set the top-level predicate. -% '$set_file_search_paths', % Define search paths for files. -% init_debug_flags, % Initialize debugging flags. -% start_pldoc, % Start the Prolog documentation server (pldoc). -% opt_attach_packs, % Attach optional packs (libraries). -% load_init_file, % Load the user initialization file. -% catch(setup_backtrace, E1, print_message(warning, E1)), % Setup backtrace handling, catching errors. -% %catch(setup_readline, E2, print_message(warning, E2)), % Setup readline, previously caught and skipped. -% %catch(setup_history, E3, print_message(warning, E3)), % Setup history management, previously skipped. -% catch(setup_colors, E4, print_message(warning, E4))), % Setup color scheme, catching any errors. -% install_readline(Input). % Main installation of readline for Input stream. - -%! command(+KeyCode, -Command) is det. -% -% Maps key codes to corresponding commands for the debugger and terminal interactions. -% This predicate associates specific key codes with debugger commands, providing an easy interface for users. -% -% @arg KeyCode The ASCII code of the key pressed. -% @arg Command The debugger command associated with that key press. -% -% @example Example of usage: -% -% ?- command(59, Command). -% Command = retry. -% -command(59, retry). % ';' to retry the previous goal -command(115, skip). % 's' to skip to the next solution -command(108, leap). % 'l' to leap (end the debugging session) -command(103, goals). % 'g' to show the current goals -command(102, fail). % 'f' to force the current goal to fail -command(116, trace). % 't' to toggle tracing on or off -command(117, up). % 'u' to continue execution without interruption -command(101, exit). % 'e' to exit the debugger -command(97, abort). % 'a' to abort execution -command(98, break). % 'b' to set a breakpoint -command(99, creep). % 'c' to proceed step by step -command(104, help). % 'h' for help with debugger commands -command(65, alternatives). % 'A' to show alternatives for the current goal -command(109, make). % 'm' to recompile and reload code (make/0) -command(67, compile). % 'C' to compile new code into an executable - -:- style_check(-singleton). - -% Command implementations - -%! handle_command(+Command, +Variables, +Goal, +Tracing) is det. -% -% Handles debugger commands such as retry, make, compile, and trace. -% Each command has specific behavior related to goal tracing, code compilation, or debugging interaction. -% -% @arg Command is the command to be executed. -% @arg Variables are the current variables in scope during debugging. -% @arg Goal is the current goal being debugged. -% @arg Tracing is the tracing mode (e.g., trace_on, trace_off). -% -% This command dispatcher defines custom behavior for interacting with debugging and recompilation processes. -% -% @example Handling the 'make' command: -% -% ?- handle_command(make, Vars, Goal, Tracing). -% Recompiling... -% true. -% - -% Handle the 'make' command by recompiling the code. -handle_command(make, Variables, Goal, Tracing) :- - writeln('Recompiling...'), - % Recompiles the entire code base. This assumes `make/0` is defined in your Prolog system. - make, % Triggers the recompilation process. - fail. % Fails to continue interacting after recompilation. -% Handle the 'compile' command by compiling a new executable. -handle_command(compile, Variables, Goal, Tracing) :- - writeln('Compiling new executable...'), - % Compilation logic should go here. For example, using qsave_program/2 to create an executable. - % Pseudocode: compile_executable(ExecutableName) - fail. % Fails to continue interacting after compilation. -% Handle the 'alternatives' command by showing alternative clauses for the current goal. -handle_command(alternatives, Variables, Goal, Tracing) :- - writeln('Showing alternatives...'), - writeln('Alternatives for current goal:'), - writeln(Goal), - % Pseudocode for finding and displaying alternatives: find_alternatives(Goal, Alternatives) - % Pseudocode for printing alternatives: print_alternatives(Alternatives) - fail. % Fails to continue interacting after showing alternatives. -% Handle the 'help' command by printing help information. -handle_command(help, Variables, Goal, Tracing) :- - print_help, % A helper predicate to print command help information. - fail. % Fails to continue interacting after showing help. -% Handle the 'abort' command by aborting the execution. -handle_command(abort, _, _, _) :- - writeln('Aborting...'), - abort. -% Handle the 'break' command by setting a breakpoint. -handle_command(break, Variables, Goal, Tracing) :- - writeln('Breakpoint set.'), - fail. % Fails to continue interacting after setting a breakpoint. -% Handle the 'creep' command by entering step-by-step execution mode. -handle_command(creep, Variables, Goal, Tracing) :- - writeln('Creeping...'), % Step-by-step execution starts here. - trace. % Enables tracing (creep mode). -% Handle the 'retry' command by retrying the current goal. -handle_command(retry, Variables, Goal, Tracing) :- - writeln('Continuing...'),!. -% Handle the 'skip' command by skipping the current goal. -handle_command(skip, Variables, Goal, Tracing) :- - writeln('Skipping...'). -% Handle the 'leap' command by exiting trace mode and continuing execution. -handle_command(leap, _, _, _) :- - writeln('Leaping...'), nontrace. % Exits trace mode and continues execution. -% Handle the 'goals' command by showing the current goal and variables. -handle_command(goals, Variables, Goal, Tracing) :- - writeln('Current goal:'), - writeln(Goal), - writeln('Current variables:'), - writeln(Variables), - bt, fail. % Displays the current backtrace and fails to continue interacting. -% Handle the 'fail' command by forcing the current goal to fail. -handle_command(fail, _, _, _) :- - writeln('Forcing failure...'), - fail. -% Handle the 'trace' command by toggling tracing on and off. -handle_command(trace, Variables, Goal, Tracing) :- - (Tracing == trace_on -> - NewTracing = trace_off, - writeln('Tracing disabled.') - ; NewTracing = trace_on, - writeln('Tracing enabled.') - ), - interact(Variables, Goal, NewTracing). % Continue interacting with the updated tracing state. -% Handle the 'up' command by continuing execution until the next traceable goal. -handle_command(up, Variables, Goal, Tracing) :- - writeln('Continuing up...'), - repeat, - ( trace_goal(Goal, Tracing) -> true ; !, fail ). -% Handle the 'exit' command by exiting the debugger. -handle_command(exit, _, _, _) :- - writeln('Exiting debugger...'), !. % Cuts to ensure we exit the debugger. - -% Directive to disable singleton variable warnings, which may occur often in dynamic code. -:- style_check(+singleton). - - -%! print_help is det. -% -% Prints the help message for available debugger commands. -% -% This message includes a list of all recognized commands that a user can issue in the debugger. -% -% @example To view the help message: -% -% ?- print_help. -% -print_help :- - % Print each available debugger command with its description. - writeln('Debugger commands:'), - writeln('(;) next - Retry with next solution.'), - writeln('(g) goal - Show the current goal.'), - writeln('(u) up - Finish this goal without interruption.'), - writeln('(s) skip - Skip to the next solution.'), - writeln('(c) creep or - Proceed step by step.'), - writeln('(l) leap - Leap over (the debugging).'), - writeln('(f) fail - Force the current goal to fail.'), - writeln('(B) back - Go back to the previous step.'), - writeln('(t) trace - Toggle tracing on or off.'), - writeln('(e) exit - Exit the debugger.'), - writeln('(a) abort - Abort the current operation.'), - writeln('(b) break - Break to a new sub-REPL.'), - writeln('(h) help - Display this help message.'), - writeln('(A) alternatives - Show alternative solutions.'), - writeln('(m) make - Recompile/Update the current running code.'), - writeln('(C) compile - Compile a fresh executable (based on the running state).'), - writeln('(E) error msg - Show the latest error messages.'), - writeln('(r) retry - Retry the previous command.'), - writeln('(I) info - Show information about the current state.'), - !. - diff --git a/.Attic/metta_lang/stdlib_mettalog.metta.buffer~ b/.Attic/metta_lang/stdlib_mettalog.metta.buffer~ deleted file mode 100644 index 44597e9353..0000000000 --- a/.Attic/metta_lang/stdlib_mettalog.metta.buffer~ +++ /dev/null @@ -1,8593 +0,0 @@ -afn_stem_filename('/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta','/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta','/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta'). -:-multifile user:afn_stem_filename/3. -:-dynamic user:metta_file_buffer/7. -:-multifile user:metta_file_buffer/7. -user:metta_file_buffer(0,1000000,indexed(metta_comment,";; Type Declarations with Documentation"),'$COMMENT'(";; Type Declarations with Documentation",0,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(0,0),line_char(0,39))). -user:metta_file_buffer(1,1000001,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2,1),line_char(2,5))). -user:metta_file_buffer(1,1000001,constant,'Any',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2,6),line_char(2,9))). -user:metta_file_buffer(2,1000002,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(3,3),line_char(3,8))). -user:metta_file_buffer(2,1000002,string,"The universal type; any value belongs to this type.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(3,9),line_char(3,62))). -user:metta_file_buffer(1,1000002,metta_other,['@desc',"The universal type; any value belongs to this type."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(3,2),line_char(3,63))). -user:metta_file_buffer(0,1000002,decl(doc),['@doc','Any',['@desc',"The universal type; any value belongs to this type."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2,0),line_char(3,64))). -user:metta_file_buffer(1,2000003,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(4,1),line_char(4,2))). -user:metta_file_buffer(1,2000003,constant,'Any',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(4,3),line_char(4,6))). -user:metta_file_buffer(1,2000003,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(4,7),line_char(4,11))). -user:metta_file_buffer(0,2000003,decl(ftype),[:,'Any','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(4,0),line_char(4,12))). -user:metta_file_buffer(1,3000004,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(6,1),line_char(6,5))). -user:metta_file_buffer(1,3000004,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(6,6),line_char(6,10))). -user:metta_file_buffer(2,3000005,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(7,3),line_char(7,8))). -user:metta_file_buffer(2,3000005,string,"Type representing any atom.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(7,9),line_char(7,38))). -user:metta_file_buffer(1,3000005,metta_other,['@desc',"Type representing any atom."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(7,2),line_char(7,39))). -user:metta_file_buffer(0,3000005,decl(doc),['@doc','Atom',['@desc',"Type representing any atom."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(6,0),line_char(7,40))). -user:metta_file_buffer(1,4000006,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(8,1),line_char(8,2))). -user:metta_file_buffer(1,4000006,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(8,3),line_char(8,7))). -user:metta_file_buffer(1,4000006,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(8,8),line_char(8,12))). -user:metta_file_buffer(0,4000006,decl(ftype),[:,'Atom','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(8,0),line_char(8,13))). -user:metta_file_buffer(1,5000007,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(10,1),line_char(10,5))). -user:metta_file_buffer(1,5000007,constant,'LazyEvaluatable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(10,6),line_char(10,21))). -user:metta_file_buffer(2,5000008,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(11,3),line_char(11,8))). -user:metta_file_buffer(2,5000008,string,"A type of Atom/Value that hyperon does not implicitly evaluate",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(11,9),line_char(11,73))). -user:metta_file_buffer(1,5000008,metta_other,['@desc',"A type of Atom/Value that hyperon does not implicitly evaluate"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(11,2),line_char(11,74))). -user:metta_file_buffer(0,5000008,decl(doc),['@doc','LazyEvaluatable',['@desc',"A type of Atom/Value that hyperon does not implicitly evaluate"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(10,0),line_char(11,75))). -user:metta_file_buffer(1,6000009,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(12,1),line_char(12,2))). -user:metta_file_buffer(1,6000009,constant,'LazyEvaluatable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(12,3),line_char(12,18))). -user:metta_file_buffer(1,6000009,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(12,19),line_char(12,23))). -user:metta_file_buffer(0,6000009,decl(ftype),[:,'LazyEvaluatable','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(12,0),line_char(12,24))). -user:metta_file_buffer(1,7000010,constant,:>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(13,1),line_char(13,3))). -user:metta_file_buffer(1,7000010,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(13,4),line_char(13,8))). -user:metta_file_buffer(1,7000010,constant,'LazyEvaluatable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(13,9),line_char(13,24))). -user:metta_file_buffer(0,7000010,decl(impl),[:>,'Atom','LazyEvaluatable'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(13,0),line_char(13,25))). -user:metta_file_buffer(1,8000011,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(15,1),line_char(15,5))). -user:metta_file_buffer(1,8000011,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(15,6),line_char(15,10))). -user:metta_file_buffer(2,8000012,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(16,3),line_char(16,8))). -user:metta_file_buffer(2,8000012,string,"Boolean type of True or False.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(16,9),line_char(16,41))). -user:metta_file_buffer(1,8000012,metta_other,['@desc',"Boolean type of True or False."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(16,2),line_char(16,42))). -user:metta_file_buffer(0,8000012,decl(doc),['@doc','Bool',['@desc',"Boolean type of True or False."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(15,0),line_char(16,43))). -user:metta_file_buffer(1,9000013,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(17,1),line_char(17,2))). -user:metta_file_buffer(1,9000013,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(17,3),line_char(17,7))). -user:metta_file_buffer(1,9000013,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(17,8),line_char(17,12))). -user:metta_file_buffer(0,9000013,decl(ftype),[:,'Bool','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(17,0),line_char(17,13))). -user:metta_file_buffer(1,10000014,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(19,1),line_char(19,5))). -user:metta_file_buffer(1,10000014,constant,'LazyBool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(19,6),line_char(19,14))). -user:metta_file_buffer(2,10000015,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(20,3),line_char(20,8))). -user:metta_file_buffer(2,10000015,string,"A LazyEvaluatable that when evaluated returns True or False.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(20,9),line_char(20,71))). -user:metta_file_buffer(1,10000015,metta_other,['@desc',"A LazyEvaluatable that when evaluated returns True or False."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(20,2),line_char(20,72))). -user:metta_file_buffer(0,10000015,decl(doc),['@doc','LazyBool',['@desc',"A LazyEvaluatable that when evaluated returns True or False."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(19,0),line_char(20,73))). -user:metta_file_buffer(1,11000016,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(21,1),line_char(21,2))). -user:metta_file_buffer(1,11000016,constant,'LazyBool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(21,3),line_char(21,11))). -user:metta_file_buffer(1,11000016,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(21,12),line_char(21,16))). -user:metta_file_buffer(0,11000016,decl(ftype),[:,'LazyBool','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(21,0),line_char(21,17))). -user:metta_file_buffer(1,12000017,constant,:>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(22,1),line_char(22,3))). -user:metta_file_buffer(1,12000017,constant,'LazyBool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(22,4),line_char(22,12))). -user:metta_file_buffer(1,12000017,constant,'LazyEvaluatable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(22,13),line_char(22,28))). -user:metta_file_buffer(0,12000017,decl(impl),[:>,'LazyBool','LazyEvaluatable'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(22,0),line_char(22,29))). -user:metta_file_buffer(1,13000018,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(24,1),line_char(24,5))). -user:metta_file_buffer(1,13000018,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(24,6),line_char(24,16))). -user:metta_file_buffer(2,13000019,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(25,3),line_char(25,8))). -user:metta_file_buffer(2,13000019,string,"Type representing an S-Expression, which is a combination of atoms.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(25,9),line_char(25,78))). -user:metta_file_buffer(1,13000019,metta_other,['@desc',"Type representing an S-Expression, which is a combination of atoms."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(25,2),line_char(25,79))). -user:metta_file_buffer(0,13000019,decl(doc),['@doc','Expression',['@desc',"Type representing an S-Expression, which is a combination of atoms."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(24,0),line_char(25,80))). -user:metta_file_buffer(1,14000020,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(26,1),line_char(26,2))). -user:metta_file_buffer(1,14000020,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(26,3),line_char(26,13))). -user:metta_file_buffer(1,14000020,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(26,14),line_char(26,18))). -user:metta_file_buffer(0,14000020,decl(ftype),[:,'Expression','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(26,0),line_char(26,19))). -user:metta_file_buffer(1,15000021,constant,:>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(27,1),line_char(27,3))). -user:metta_file_buffer(1,15000021,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(27,4),line_char(27,14))). -user:metta_file_buffer(1,15000021,constant,'LazyEvaluatable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(27,15),line_char(27,30))). -user:metta_file_buffer(0,15000021,decl(impl),[:>,'Expression','LazyEvaluatable'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(27,0),line_char(27,31))). -user:metta_file_buffer(1,16000022,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(29,1),line_char(29,5))). -user:metta_file_buffer(1,16000022,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(29,6),line_char(29,12))). -user:metta_file_buffer(2,16000023,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(30,3),line_char(30,8))). -user:metta_file_buffer(2,16000023,string,"Numeric type, including integers and floating-point numbers.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(30,9),line_char(30,71))). -user:metta_file_buffer(1,16000023,metta_other,['@desc',"Numeric type, including integers and floating-point numbers."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(30,2),line_char(30,72))). -user:metta_file_buffer(0,16000023,decl(doc),['@doc','Number',['@desc',"Numeric type, including integers and floating-point numbers."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(29,0),line_char(30,73))). -user:metta_file_buffer(1,17000024,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(31,1),line_char(31,2))). -user:metta_file_buffer(1,17000024,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(31,3),line_char(31,9))). -user:metta_file_buffer(1,17000024,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(31,10),line_char(31,14))). -user:metta_file_buffer(0,17000024,decl(ftype),[:,'Number','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(31,0),line_char(31,15))). -user:metta_file_buffer(1,18000025,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(33,1),line_char(33,5))). -user:metta_file_buffer(1,18000025,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(33,6),line_char(33,30))). -user:metta_file_buffer(2,18000026,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(34,3),line_char(34,8))). -user:metta_file_buffer(2,18000026,string,"Dynamic space type, representing an Atomspace.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(34,9),line_char(34,57))). -user:metta_file_buffer(1,18000026,metta_other,['@desc',"Dynamic space type, representing an Atomspace."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(34,2),line_char(34,58))). -user:metta_file_buffer(0,18000026,decl(doc),['@doc','hyperon::space::DynSpace',['@desc',"Dynamic space type, representing an Atomspace."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(33,0),line_char(34,59))). -user:metta_file_buffer(1,19000027,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(35,1),line_char(35,2))). -user:metta_file_buffer(1,19000027,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(35,3),line_char(35,27))). -user:metta_file_buffer(1,19000027,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(35,28),line_char(35,32))). -user:metta_file_buffer(0,19000027,decl(ftype),[:,'hyperon::space::DynSpace','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(35,0),line_char(35,33))). -user:metta_file_buffer(1,20000028,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(37,1),line_char(37,5))). -user:metta_file_buffer(1,20000028,constant,'ReturnType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(37,6),line_char(37,16))). -user:metta_file_buffer(2,20000029,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(38,3),line_char(38,8))). -user:metta_file_buffer(2,20000029,string,"Type representing a function's return value.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(38,9),line_char(38,55))). -user:metta_file_buffer(1,20000029,metta_other,['@desc',"Type representing a function's return value."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(38,2),line_char(38,56))). -user:metta_file_buffer(0,20000029,decl(doc),['@doc','ReturnType',['@desc',"Type representing a function's return value."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(37,0),line_char(38,57))). -user:metta_file_buffer(1,21000030,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(39,1),line_char(39,2))). -user:metta_file_buffer(1,21000030,constant,'ReturnType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(39,3),line_char(39,13))). -user:metta_file_buffer(1,21000030,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(39,14),line_char(39,18))). -user:metta_file_buffer(0,21000030,decl(ftype),[:,'ReturnType','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(39,0),line_char(39,19))). -user:metta_file_buffer(1,22000031,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(41,1),line_char(41,5))). -user:metta_file_buffer(1,22000031,constant,'Symbol',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(41,6),line_char(41,12))). -user:metta_file_buffer(2,22000032,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(42,3),line_char(42,8))). -user:metta_file_buffer(2,22000032,string,"Type representing a symbol or identifier.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(42,9),line_char(42,52))). -user:metta_file_buffer(1,22000032,metta_other,['@desc',"Type representing a symbol or identifier."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(42,2),line_char(42,53))). -user:metta_file_buffer(0,22000032,decl(doc),['@doc','Symbol',['@desc',"Type representing a symbol or identifier."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(41,0),line_char(42,54))). -user:metta_file_buffer(1,23000033,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(43,1),line_char(43,2))). -user:metta_file_buffer(1,23000033,constant,'Symbol',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(43,3),line_char(43,9))). -user:metta_file_buffer(1,23000033,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(43,10),line_char(43,14))). -user:metta_file_buffer(0,23000033,decl(ftype),[:,'Symbol','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(43,0),line_char(43,15))). -user:metta_file_buffer(1,24000034,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(45,1),line_char(45,5))). -user:metta_file_buffer(1,24000034,constant,'StateMonad',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(45,6),line_char(45,16))). -user:metta_file_buffer(2,24000035,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(46,3),line_char(46,8))). -user:metta_file_buffer(2,24000035,string,"Type representing a state monad, used for encapsulating stateful computations.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(46,9),line_char(46,89))). -user:metta_file_buffer(1,24000035,metta_other,['@desc',"Type representing a state monad, used for encapsulating stateful computations."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(46,2),line_char(46,90))). -user:metta_file_buffer(0,24000035,decl(doc),['@doc','StateMonad',['@desc',"Type representing a state monad, used for encapsulating stateful computations."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(45,0),line_char(46,91))). -user:metta_file_buffer(1,25000036,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(47,1),line_char(47,2))). -user:metta_file_buffer(1,25000036,constant,'StateMonad',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(47,3),line_char(47,13))). -user:metta_file_buffer(1,25000036,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(47,14),line_char(47,18))). -user:metta_file_buffer(0,25000036,decl(ftype),[:,'StateMonad','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(47,0),line_char(47,19))). -user:metta_file_buffer(1,26000037,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(49,1),line_char(49,5))). -user:metta_file_buffer(1,26000037,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(49,6),line_char(49,10))). -user:metta_file_buffer(2,26000038,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(50,3),line_char(50,8))). -user:metta_file_buffer(2,26000038,string,"Type representing a type.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(50,9),line_char(50,36))). -user:metta_file_buffer(1,26000038,metta_other,['@desc',"Type representing a type."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(50,2),line_char(50,37))). -user:metta_file_buffer(0,26000038,decl(doc),['@doc','Type',['@desc',"Type representing a type."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(49,0),line_char(50,38))). -user:metta_file_buffer(1,27000039,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(51,1),line_char(51,2))). -user:metta_file_buffer(1,27000039,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(51,3),line_char(51,7))). -user:metta_file_buffer(1,27000039,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(51,8),line_char(51,12))). -user:metta_file_buffer(0,27000039,decl(ftype),[:,'Type','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(51,0),line_char(51,13))). -user:metta_file_buffer(1,28000040,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(53,1),line_char(53,5))). -user:metta_file_buffer(1,28000040,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(53,6),line_char(53,10))). -user:metta_file_buffer(2,28000041,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(54,3),line_char(54,8))). -user:metta_file_buffer(2,28000041,string,"Boolean value representing truth.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(54,9),line_char(54,44))). -user:metta_file_buffer(1,28000041,metta_other,['@desc',"Boolean value representing truth."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(54,2),line_char(54,45))). -user:metta_file_buffer(0,28000041,decl(doc),['@doc','True',['@desc',"Boolean value representing truth."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(53,0),line_char(54,46))). -user:metta_file_buffer(1,29000042,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(55,1),line_char(55,2))). -user:metta_file_buffer(1,29000042,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(55,3),line_char(55,7))). -user:metta_file_buffer(1,29000042,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(55,8),line_char(55,12))). -user:metta_file_buffer(0,29000042,decl(ftype),[:,'True','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(55,0),line_char(55,13))). -user:metta_file_buffer(1,30000043,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(57,1),line_char(57,5))). -user:metta_file_buffer(1,30000043,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(57,6),line_char(57,11))). -user:metta_file_buffer(2,30000044,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(58,3),line_char(58,8))). -user:metta_file_buffer(2,30000044,string,"Boolean value representing falsehood.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(58,9),line_char(58,48))). -user:metta_file_buffer(1,30000044,metta_other,['@desc',"Boolean value representing falsehood."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(58,2),line_char(58,49))). -user:metta_file_buffer(0,30000044,decl(doc),['@doc','False',['@desc',"Boolean value representing falsehood."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(57,0),line_char(58,50))). -user:metta_file_buffer(1,31000045,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(59,1),line_char(59,2))). -user:metta_file_buffer(1,31000045,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(59,3),line_char(59,8))). -user:metta_file_buffer(1,31000045,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(59,9),line_char(59,13))). -user:metta_file_buffer(0,31000045,decl(ftype),[:,'False','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(59,0),line_char(59,14))). -user:metta_file_buffer(1,32000046,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(61,1),line_char(61,5))). -user:metta_file_buffer(1,32000046,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(61,6),line_char(61,17))). -user:metta_file_buffer(2,32000047,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(62,3),line_char(62,8))). -user:metta_file_buffer(2,32000047,string,"Special type representing an undefined value or type.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(62,9),line_char(62,64))). -user:metta_file_buffer(1,32000047,metta_other,['@desc',"Special type representing an undefined value or type."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(62,2),line_char(62,65))). -user:metta_file_buffer(0,32000047,decl(doc),['@doc','%Undefined%',['@desc',"Special type representing an undefined value or type."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(61,0),line_char(62,66))). -user:metta_file_buffer(1,33000048,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(63,1),line_char(63,2))). -user:metta_file_buffer(1,33000048,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(63,3),line_char(63,14))). -user:metta_file_buffer(1,33000048,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(63,15),line_char(63,19))). -user:metta_file_buffer(0,33000048,decl(ftype),[:,'%Undefined%','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(63,0),line_char(63,20))). -user:metta_file_buffer(1,34000049,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(65,1),line_char(65,5))). -user:metta_file_buffer(1,34000049,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(65,6),line_char(65,14))). -user:metta_file_buffer(2,34000050,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(66,3),line_char(66,8))). -user:metta_file_buffer(2,34000050,string,"Type representing a variable in the language.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(66,9),line_char(66,56))). -user:metta_file_buffer(1,34000050,metta_other,['@desc',"Type representing a variable in the language."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(66,2),line_char(66,57))). -user:metta_file_buffer(0,34000050,decl(doc),['@doc','Variable',['@desc',"Type representing a variable in the language."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(65,0),line_char(66,58))). -user:metta_file_buffer(1,35000051,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(67,1),line_char(67,2))). -user:metta_file_buffer(1,35000051,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(67,3),line_char(67,11))). -user:metta_file_buffer(1,35000051,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(67,12),line_char(67,16))). -user:metta_file_buffer(0,35000051,decl(ftype),[:,'Variable','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(67,0),line_char(67,17))). -user:metta_file_buffer(1,36000052,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(69,1),line_char(69,5))). -user:metta_file_buffer(1,36000052,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(69,6),line_char(69,7))). -user:metta_file_buffer(2,36000053,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(70,3),line_char(70,8))). -user:metta_file_buffer(2,36000053,string,"Type declarion operator",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(70,9),line_char(70,34))). -user:metta_file_buffer(1,36000053,metta_other,['@desc',"Type declarion operator"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(70,2),line_char(70,35))). -user:metta_file_buffer(0,36000053,decl(doc),['@doc',:,['@desc',"Type declarion operator"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(69,0),line_char(70,36))). -user:metta_file_buffer(1,37000054,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(71,1),line_char(71,5))). -user:metta_file_buffer(1,37000054,constant,<:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(71,6),line_char(71,8))). -user:metta_file_buffer(2,37000055,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(72,3),line_char(72,8))). -user:metta_file_buffer(2,37000055,string,"Super Type declarion operator",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(72,9),line_char(72,40))). -user:metta_file_buffer(1,37000055,metta_other,['@desc',"Super Type declarion operator"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(72,2),line_char(72,41))). -user:metta_file_buffer(0,37000055,decl(doc),['@doc',<:,['@desc',"Super Type declarion operator"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(71,0),line_char(72,42))). -user:metta_file_buffer(1,38000056,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(73,1),line_char(73,2))). -user:metta_file_buffer(1,38000056,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(73,3),line_char(73,4))). -user:metta_file_buffer(1,38000056,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(73,5),line_char(73,16))). -user:metta_file_buffer(0,38000056,decl(ftype),[:,:,'%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(73,0),line_char(73,17))). -user:metta_file_buffer(0,39000056,indexed(metta_comment,"; match hyperons weirdd return value of !(get-type :)"),'$COMMENT'("; match hyperons weirdd return value of !(get-type :)",73,18),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(73,18),line_char(73,71))). -user:metta_file_buffer(1,39000057,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(76,1),line_char(76,2))). -user:metta_file_buffer(1,39000057,constant,'if-empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(76,3),line_char(76,11))). -user:metta_file_buffer(2,39000058,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(76,13),line_char(76,15))). -user:metta_file_buffer(2,39000058,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(76,16),line_char(76,20))). -user:metta_file_buffer(2,39000058,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(76,21),line_char(76,25))). -user:metta_file_buffer(2,39000058,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(76,26),line_char(76,30))). -user:metta_file_buffer(2,39000058,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(76,31),line_char(76,35))). -user:metta_file_buffer(1,39000058,metta_other,[->,'Atom','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(76,12),line_char(76,36))). -user:metta_file_buffer(0,39000058,decl(ftype),[:,'if-empty',[->,'Atom','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(76,0),line_char(76,37))). -user:metta_file_buffer(1,40000059,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(77,1),line_char(77,2))). -user:metta_file_buffer(1,40000059,constant,'if-non-empty-expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(77,3),line_char(77,26))). -user:metta_file_buffer(2,40000060,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(77,28),line_char(77,30))). -user:metta_file_buffer(2,40000060,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(77,31),line_char(77,35))). -user:metta_file_buffer(2,40000060,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(77,36),line_char(77,40))). -user:metta_file_buffer(2,40000060,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(77,41),line_char(77,45))). -user:metta_file_buffer(2,40000060,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(77,46),line_char(77,50))). -user:metta_file_buffer(1,40000060,metta_other,[->,'Atom','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(77,27),line_char(77,51))). -user:metta_file_buffer(0,40000060,decl(ftype),[:,'if-non-empty-expression',[->,'Atom','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(77,0),line_char(77,52))). -user:metta_file_buffer(1,41000061,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(78,1),line_char(78,2))). -user:metta_file_buffer(1,41000061,constant,'if-not-reducible',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(78,3),line_char(78,19))). -user:metta_file_buffer(2,41000062,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(78,21),line_char(78,23))). -user:metta_file_buffer(2,41000062,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(78,24),line_char(78,28))). -user:metta_file_buffer(2,41000062,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(78,29),line_char(78,33))). -user:metta_file_buffer(2,41000062,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(78,34),line_char(78,38))). -user:metta_file_buffer(2,41000062,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(78,39),line_char(78,43))). -user:metta_file_buffer(1,41000062,metta_other,[->,'Atom','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(78,20),line_char(78,44))). -user:metta_file_buffer(0,41000062,decl(ftype),[:,'if-not-reducible',[->,'Atom','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(78,0),line_char(78,45))). -user:metta_file_buffer(1,42000063,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(79,1),line_char(79,2))). -user:metta_file_buffer(1,42000063,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(79,3),line_char(79,9))). -user:metta_file_buffer(2,42000064,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(79,11),line_char(79,13))). -user:metta_file_buffer(2,42000064,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(79,14),line_char(79,18))). -user:metta_file_buffer(2,42000064,constant,'ReturnType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(79,19),line_char(79,29))). -user:metta_file_buffer(1,42000064,metta_other,[->,'Atom','ReturnType'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(79,10),line_char(79,30))). -user:metta_file_buffer(0,42000064,decl(ftype),[:,return,[->,'Atom','ReturnType']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(79,0),line_char(79,31))). -user:metta_file_buffer(1,43000065,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(80,1),line_char(80,2))). -user:metta_file_buffer(1,43000065,constant,switch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(80,3),line_char(80,9))). -user:metta_file_buffer(2,43000066,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(80,11),line_char(80,13))). -user:metta_file_buffer(2,43000066,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(80,14),line_char(80,25))). -user:metta_file_buffer(2,43000066,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(80,26),line_char(80,36))). -user:metta_file_buffer(2,43000066,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(80,37),line_char(80,41))). -user:metta_file_buffer(1,43000066,metta_other,[->,'%Undefined%','Expression','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(80,10),line_char(80,42))). -user:metta_file_buffer(0,43000066,decl(ftype),[:,switch,[->,'%Undefined%','Expression','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(80,0),line_char(80,43))). -user:metta_file_buffer(1,44000067,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(81,1),line_char(81,2))). -user:metta_file_buffer(1,44000067,constant,unify,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(81,3),line_char(81,8))). -user:metta_file_buffer(2,44000068,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(81,10),line_char(81,12))). -user:metta_file_buffer(2,44000068,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(81,13),line_char(81,17))). -user:metta_file_buffer(2,44000068,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(81,18),line_char(81,22))). -user:metta_file_buffer(2,44000068,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(81,23),line_char(81,27))). -user:metta_file_buffer(2,44000068,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(81,28),line_char(81,32))). -user:metta_file_buffer(2,44000068,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(81,33),line_char(81,44))). -user:metta_file_buffer(1,44000068,metta_other,[->,'Atom','Atom','Atom','Atom','%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(81,9),line_char(81,45))). -user:metta_file_buffer(0,44000068,decl(ftype),[:,unify,[->,'Atom','Atom','Atom','Atom','%Undefined%']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(81,0),line_char(81,46))). -user:metta_file_buffer(1,45000069,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(83,1),line_char(83,2))). -user:metta_file_buffer(1,45000069,constant,'get-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(83,3),line_char(83,11))). -user:metta_file_buffer(2,45000070,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(83,13),line_char(83,15))). -user:metta_file_buffer(2,45000070,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(83,16),line_char(83,20))). -user:metta_file_buffer(2,45000070,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(83,21),line_char(83,25))). -user:metta_file_buffer(1,45000070,metta_other,[->,'Atom','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(83,12),line_char(83,26))). -user:metta_file_buffer(0,45000070,decl(ftype),[:,'get-type',[->,'Atom','Type']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(83,0),line_char(83,27))). -user:metta_file_buffer(0,46000070,indexed(metta_comment,"; get all type declarations for Atom"),'$COMMENT'("; get all type declarations for Atom",83,28),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(83,28),line_char(83,64))). -user:metta_file_buffer(1,46000071,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(84,1),line_char(84,2))). -user:metta_file_buffer(1,46000071,constant,'get-type0',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(84,3),line_char(84,12))). -user:metta_file_buffer(2,46000072,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(84,14),line_char(84,16))). -user:metta_file_buffer(2,46000072,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(84,17),line_char(84,21))). -user:metta_file_buffer(2,46000072,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(84,22),line_char(84,26))). -user:metta_file_buffer(1,46000072,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(84,13),line_char(84,27))). -user:metta_file_buffer(0,46000072,decl(ftype),[:,'get-type0',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(84,0),line_char(84,28))). -user:metta_file_buffer(0,47000072,indexed(metta_comment,"; get-type now returns multiple return values.. this act like the old one that reutrns a sngle value"),'$COMMENT'("; get-type now returns multiple return values.. this act like the old one that reutrns a sngle value",84,29),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(84,29),line_char(84,129))). -user:metta_file_buffer(1,47000073,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(85,1),line_char(85,2))). -user:metta_file_buffer(1,47000073,constant,'get-ftype',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(85,3),line_char(85,12))). -user:metta_file_buffer(2,47000074,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(85,14),line_char(85,16))). -user:metta_file_buffer(2,47000074,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(85,17),line_char(85,21))). -user:metta_file_buffer(2,47000074,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(85,22),line_char(85,26))). -user:metta_file_buffer(1,47000074,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(85,13),line_char(85,27))). -user:metta_file_buffer(0,47000074,decl(ftype),[:,'get-ftype',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(85,0),line_char(85,28))). -user:metta_file_buffer(0,48000074,indexed(metta_comment,"; returns only the function types of a symbol"),'$COMMENT'("; returns only the function types of a symbol",85,29),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(85,29),line_char(85,74))). -user:metta_file_buffer(1,48000075,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(87,1),line_char(87,2))). -user:metta_file_buffer(1,48000075,constant,'pragma!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(87,3),line_char(87,10))). -user:metta_file_buffer(2,48000076,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(87,12),line_char(87,14))). -user:metta_file_buffer(2,48000076,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(87,15),line_char(87,19))). -user:metta_file_buffer(2,48000076,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(87,20),line_char(87,24))). -user:metta_file_buffer(3,48000077,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(87,26),line_char(87,28))). -user:metta_file_buffer(2,48000077,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(87,25),line_char(87,29))). -user:metta_file_buffer(1,48000077,metta_other,[->,'Atom','Atom',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(87,11),line_char(87,30))). -user:metta_file_buffer(0,48000077,decl(ftype),[:,'pragma!',[->,'Atom','Atom',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(87,0),line_char(87,31))). -user:metta_file_buffer(1,49000078,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(88,1),line_char(88,2))). -user:metta_file_buffer(1,49000078,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(88,3),line_char(88,4))). -user:metta_file_buffer(2,49000079,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(88,6),line_char(88,8))). -user:metta_file_buffer(2,49000079,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(88,9),line_char(88,13))). -user:metta_file_buffer(2,49000079,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(88,14),line_char(88,18))). -user:metta_file_buffer(2,49000079,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(88,19),line_char(88,30))). -user:metta_file_buffer(1,49000079,metta_other,[->,'Atom','Atom','%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(88,5),line_char(88,31))). -user:metta_file_buffer(0,49000079,decl(ftype),[:,=,[->,'Atom','Atom','%Undefined%']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(88,0),line_char(88,32))). -user:metta_file_buffer(1,50000080,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(89,1),line_char(89,2))). -user:metta_file_buffer(1,50000080,constant,match,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(89,3),line_char(89,8))). -user:metta_file_buffer(2,50000081,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(89,10),line_char(89,12))). -user:metta_file_buffer(2,50000081,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(89,13),line_char(89,37))). -user:metta_file_buffer(2,50000081,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(89,38),line_char(89,42))). -user:metta_file_buffer(2,50000081,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(89,43),line_char(89,47))). -user:metta_file_buffer(2,50000081,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(89,48),line_char(89,59))). -user:metta_file_buffer(1,50000081,metta_other,[->,'hyperon::space::DynSpace','Atom','Atom','%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(89,9),line_char(89,60))). -user:metta_file_buffer(0,50000081,decl(ftype),[:,match,[->,'hyperon::space::DynSpace','Atom','Atom','%Undefined%']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(89,0),line_char(89,61))). -user:metta_file_buffer(1,51000082,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(90,1),line_char(90,2))). -user:metta_file_buffer(1,51000082,constant,case,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(90,3),line_char(90,7))). -user:metta_file_buffer(2,51000083,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(90,9),line_char(90,11))). -user:metta_file_buffer(2,51000083,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(90,12),line_char(90,22))). -user:metta_file_buffer(2,51000083,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(90,23),line_char(90,27))). -user:metta_file_buffer(2,51000083,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(90,28),line_char(90,32))). -user:metta_file_buffer(1,51000083,metta_other,[->,'Expression','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(90,8),line_char(90,33))). -user:metta_file_buffer(0,51000083,decl(ftype),[:,case,[->,'Expression','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(90,0),line_char(90,34))). -user:metta_file_buffer(1,52000084,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(91,1),line_char(91,2))). -user:metta_file_buffer(1,52000084,constant,combine,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(91,3),line_char(91,10))). -user:metta_file_buffer(2,52000085,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(91,12),line_char(91,14))). -user:metta_file_buffer(2,52000085,variable,_43486,['_t'=_43486],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(91,15),line_char(91,17))). -user:metta_file_buffer(2,52000085,variable,_44722,['_t'=_44722],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(91,18),line_char(91,20))). -user:metta_file_buffer(2,52000085,variable,_45966,['_t'=_45966],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(91,21),line_char(91,23))). -user:metta_file_buffer(1,52000085,indexed(metta_other,[->,_46812,_46812,_46812]),[->,_46900,_46900,_46900],['_t'=_46900],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(91,11),line_char(91,24))). -user:metta_file_buffer(0,52000085,indexed(decl(ftype),[:,combine,[->,_47464,_47464,_47464]]),[:,combine,[->,_47570,_47570,_47570]],['_t'=_47570],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(91,0),line_char(91,25))). -user:metta_file_buffer(1,53000086,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(92,1),line_char(92,2))). -user:metta_file_buffer(1,53000086,constant,'import!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(92,3),line_char(92,10))). -user:metta_file_buffer(2,53000087,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(92,12),line_char(92,14))). -user:metta_file_buffer(2,53000087,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(92,15),line_char(92,39))). -user:metta_file_buffer(2,53000087,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(92,40),line_char(92,44))). -user:metta_file_buffer(3,53000088,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(92,46),line_char(92,48))). -user:metta_file_buffer(2,53000088,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(92,45),line_char(92,49))). -user:metta_file_buffer(1,53000088,metta_other,[->,'hyperon::space::DynSpace','Atom',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(92,11),line_char(92,50))). -user:metta_file_buffer(0,53000088,decl(ftype),[:,'import!',[->,'hyperon::space::DynSpace','Atom',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(92,0),line_char(92,51))). -user:metta_file_buffer(1,54000089,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(93,1),line_char(93,2))). -user:metta_file_buffer(1,54000089,constant,'If',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(93,3),line_char(93,5))). -user:metta_file_buffer(2,54000090,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(93,7),line_char(93,9))). -user:metta_file_buffer(2,54000090,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(93,10),line_char(93,14))). -user:metta_file_buffer(2,54000090,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(93,15),line_char(93,19))). -user:metta_file_buffer(2,54000090,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(93,20),line_char(93,24))). -user:metta_file_buffer(2,54000090,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(93,25),line_char(93,29))). -user:metta_file_buffer(1,54000090,metta_other,[->,'Bool','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(93,6),line_char(93,30))). -user:metta_file_buffer(0,54000090,decl(ftype),[:,'If',[->,'Bool','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(93,0),line_char(93,31))). -user:metta_file_buffer(1,55000091,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(94,1),line_char(94,2))). -user:metta_file_buffer(1,55000091,constant,'If',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(94,3),line_char(94,5))). -user:metta_file_buffer(2,55000092,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(94,7),line_char(94,9))). -user:metta_file_buffer(2,55000092,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(94,10),line_char(94,14))). -user:metta_file_buffer(2,55000092,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(94,15),line_char(94,19))). -user:metta_file_buffer(2,55000092,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(94,20),line_char(94,24))). -user:metta_file_buffer(1,55000092,metta_other,[->,'Bool','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(94,6),line_char(94,25))). -user:metta_file_buffer(0,55000092,decl(ftype),[:,'If',[->,'Bool','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(94,0),line_char(94,26))). -user:metta_file_buffer(1,56000093,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(95,1),line_char(95,2))). -user:metta_file_buffer(2,56000094,constant,'If',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(95,4),line_char(95,6))). -user:metta_file_buffer(2,56000094,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(95,7),line_char(95,11))). -user:metta_file_buffer(2,56000094,variable,_46192,['_then'=_46192],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(95,12),line_char(95,17))). -user:metta_file_buffer(1,56000094,indexed(metta_other,['If','True',_47040]),['If','True',_47098],['_then'=_47098],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(95,3),line_char(95,18))). -user:metta_file_buffer(1,56000094,variable,_48078,['_then'=_48078],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(95,19),line_char(95,24))). -user:metta_file_buffer(0,56000094,indexed(decl(impl),['If','True',_48942]),[=,['If','True',_49030],_49030],['_then'=_49030],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(95,0),line_char(95,25))). -user:metta_file_buffer(1,57000095,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,1),line_char(96,2))). -user:metta_file_buffer(2,57000096,constant,'If',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,4),line_char(96,6))). -user:metta_file_buffer(2,57000096,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,7),line_char(96,12))). -user:metta_file_buffer(2,57000096,variable,_46202,['_then'=_46202],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,13),line_char(96,18))). -user:metta_file_buffer(1,57000096,indexed(metta_other,['If','False',_47050]),['If','False',_47108],['_then'=_47108],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,3),line_char(96,19))). -user:metta_file_buffer(2,57000097,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,21),line_char(96,24))). -user:metta_file_buffer(2,57000097,variable,_48816,['_n'=_48816],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,25),line_char(96,27))). -user:metta_file_buffer(2,57000097,number,0,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,28),line_char(96,29))). -user:metta_file_buffer(3,57000098,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,31),line_char(96,34))). -user:metta_file_buffer(3,57000098,variable,_51462,['_n'=_51462],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,35),line_char(96,37))). -user:metta_file_buffer(3,57000098,number,1,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,38),line_char(96,39))). -user:metta_file_buffer(3,57000098,variable,_53332,['_n'=_53332],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,40),line_char(96,42))). -user:metta_file_buffer(2,57000098,indexed(metta_other,[let,_54178,1,_54178]),[let,_54256,1,_54256],['_n'=_54256],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,30),line_char(96,43))). -user:metta_file_buffer(1,57000098,indexed(metta_other,[let,_54802,0,[let,_54802,1,_54802]]),[let,_54922,0,[let,_54922,1,_54922]],['_n'=_54922],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,20),line_char(96,44))). -user:metta_file_buffer(0,57000098,indexed(decl(impl),['If','False',_55510]),[=,['If','False',_55686],[let,_55704,0,[let,_55704,1,_55704]]],['_n'=_55704,'_then'=_55686],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(96,0),line_char(96,45))). -user:metta_file_buffer(1,58000099,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(97,1),line_char(97,2))). -user:metta_file_buffer(2,58000100,constant,'If',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(97,4),line_char(97,6))). -user:metta_file_buffer(2,58000100,variable,_45596,['_cond'=_45596],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(97,7),line_char(97,12))). -user:metta_file_buffer(2,58000100,variable,_46880,['_then'=_46880],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(97,13),line_char(97,18))). -user:metta_file_buffer(2,58000100,variable,_48172,['_else'=_48172],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(97,19),line_char(97,24))). -user:metta_file_buffer(1,58000100,indexed(metta_other,['If',_49018,_49040,_49062]),['If',_49114,_49120,_49126],['_else'=_49126,'_then'=_49120,'_cond'=_49114],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(97,3),line_char(97,25))). -user:metta_file_buffer(2,58000101,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(97,27),line_char(97,29))). -user:metta_file_buffer(2,58000101,variable,_50896,['_cond'=_50896],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(97,30),line_char(97,35))). -user:metta_file_buffer(2,58000101,variable,_52180,['_then'=_52180],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(97,36),line_char(97,41))). -user:metta_file_buffer(2,58000101,variable,_53472,['_else'=_53472],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(97,42),line_char(97,47))). -user:metta_file_buffer(1,58000101,indexed(metta_other,[if,_54318,_54340,_54362]),[if,_54414,_54420,_54426],['_else'=_54426,'_then'=_54420,'_cond'=_54414],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(97,26),line_char(97,48))). -user:metta_file_buffer(0,58000101,indexed(decl(impl),['If',_54994,_55016,_55038]),[=,['If',_55172,_55178,_55184],[if,_55172,_55178,_55184]],['_else'=_55184,'_then'=_55178,'_cond'=_55172],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(97,0),line_char(97,49))). -user:metta_file_buffer(1,59000102,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(99,1),line_char(99,3))). -user:metta_file_buffer(1,59000102,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(99,4),line_char(99,19))). -user:metta_file_buffer(1,59000102,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(99,20),line_char(99,28))). -user:metta_file_buffer(0,59000102,decl(impl),[iz,'predicate-arity','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(99,0),line_char(99,29))). -user:metta_file_buffer(1,60000103,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(101,1),line_char(101,5))). -user:metta_file_buffer(1,60000103,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(101,6),line_char(101,21))). -user:metta_file_buffer(2,60000104,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(102,3),line_char(102,8))). -user:metta_file_buffer(2,60000104,string,"Specifies the arity (number of arguments) for a given predicate, allowing it to be queriable in the system's match framework. This is particularly useful for enabling built-in functions, such as `size-atom`, to be used as predicates in declarative contexts and run in reverse to compute inputs based on outputs.\n\nFor example:\n ; Enable the built-in function `size-atom` that takes an atom and returns the size\n as a predicate with arity 2\n (add-atom &dyn-space (predicate-arity size-atom 2))\n\n ; Now `size-atom` can be used as a predicate in pattern matching\n (match &dyn-space '(size-atom (a b c) $size) \n (The abc tuple was len $size))\n ; This pattern will resolve `Size = 3` and execute the action.\n\nAdditionally, by running `size-atom` in reverse, you can compute a new atom based on a desired size:\n (match &dyn-space '(size-atom $new-atom 4) \n (The new atom is $new-atom))\n ; This resolves `$new-atom` to a tuple of size 4, such as ($1 $2 $3 $4).\n\nThis reverse functionality is made possible because predicates can describe relationships, allowing you to infer inputs from outputs.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(102,9),line_char(119,134))). -user:metta_file_buffer(1,60000104,metta_other,['@desc',"Specifies the arity (number of arguments) for a given predicate, allowing it to be queriable in the system's match framework. This is particularly useful for enabling built-in functions, such as `size-atom`, to be used as predicates in declarative contexts and run in reverse to compute inputs based on outputs.\n\nFor example:\n ; Enable the built-in function `size-atom` that takes an atom and returns the size\n as a predicate with arity 2\n (add-atom &dyn-space (predicate-arity size-atom 2))\n\n ; Now `size-atom` can be used as a predicate in pattern matching\n (match &dyn-space '(size-atom (a b c) $size) \n (The abc tuple was len $size))\n ; This pattern will resolve `Size = 3` and execute the action.\n\nAdditionally, by running `size-atom` in reverse, you can compute a new atom based on a desired size:\n (match &dyn-space '(size-atom $new-atom 4) \n (The new atom is $new-atom))\n ; This resolves `$new-atom` to a tuple of size 4, such as ($1 $2 $3 $4).\n\nThis reverse functionality is made possible because predicates can describe relationships, allowing you to infer inputs from outputs."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(102,2),line_char(119,135))). -user:metta_file_buffer(2,60000105,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(120,3),line_char(120,10))). -user:metta_file_buffer(4,60000107,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(121,5),line_char(121,11))). -user:metta_file_buffer(4,60000107,string,"Predicate symbol",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(121,12),line_char(121,30))). -user:metta_file_buffer(4,60000107,string,"The name of the predicate whose arity is being defined.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(121,31),line_char(121,88))). -user:metta_file_buffer(3,60000107,metta_other,['@param',"Predicate symbol","The name of the predicate whose arity is being defined."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(121,4),line_char(121,89))). -user:metta_file_buffer(2,60000107,array,[['@param',"Predicate symbol","The name of the predicate whose arity is being defined."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(120,11),line_char(122,3))). -user:metta_file_buffer(1,60000107,metta_other,['@params',[['@param',"Predicate symbol","The name of the predicate whose arity is being defined."]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(120,2),line_char(122,4))). -user:metta_file_buffer(2,60000108,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(123,3),line_char(123,10))). -user:metta_file_buffer(2,60000108,string,"The number of arguments required for the predicate.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(123,11),line_char(123,64))). -user:metta_file_buffer(1,60000108,metta_other,['@return',"The number of arguments required for the predicate."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(123,2),line_char(123,65))). -user:metta_file_buffer(0,60000108,decl(doc),['@doc','predicate-arity',['@desc',"Specifies the arity (number of arguments) for a given predicate, allowing it to be queriable in the system's match framework. This is particularly useful for enabling built-in functions, such as `size-atom`, to be used as predicates in declarative contexts and run in reverse to compute inputs based on outputs.\n\nFor example:\n ; Enable the built-in function `size-atom` that takes an atom and returns the size\n as a predicate with arity 2\n (add-atom &dyn-space (predicate-arity size-atom 2))\n\n ; Now `size-atom` can be used as a predicate in pattern matching\n (match &dyn-space '(size-atom (a b c) $size) \n (The abc tuple was len $size))\n ; This pattern will resolve `Size = 3` and execute the action.\n\nAdditionally, by running `size-atom` in reverse, you can compute a new atom based on a desired size:\n (match &dyn-space '(size-atom $new-atom 4) \n (The new atom is $new-atom))\n ; This resolves `$new-atom` to a tuple of size 4, such as ($1 $2 $3 $4).\n\nThis reverse functionality is made possible because predicates can describe relationships, allowing you to infer inputs from outputs."],['@params',[['@param',"Predicate symbol","The name of the predicate whose arity is being defined."]]],['@return',"The number of arguments required for the predicate."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(101,0),line_char(123,66))). -user:metta_file_buffer(1,61000109,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(125,1),line_char(125,2))). -user:metta_file_buffer(1,61000109,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(125,3),line_char(125,18))). -user:metta_file_buffer(2,61000110,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(125,20),line_char(125,22))). -user:metta_file_buffer(2,61000110,constant,'Symbol',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(125,23),line_char(125,29))). -user:metta_file_buffer(2,61000110,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(125,30),line_char(125,36))). -user:metta_file_buffer(1,61000110,metta_other,[->,'Symbol','Number'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(125,19),line_char(125,37))). -user:metta_file_buffer(0,61000110,decl(ftype),[:,'predicate-arity',[->,'Symbol','Number']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(125,0),line_char(125,38))). -user:metta_file_buffer(1,62000111,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(126,1),line_char(126,16))). -user:metta_file_buffer(1,62000111,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(126,17),line_char(126,32))). -user:metta_file_buffer(1,62000111,number,2,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(126,33),line_char(126,34))). -user:metta_file_buffer(0,62000111,decl(impl),['predicate-arity','predicate-arity',2],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(126,0),line_char(126,35))). -user:metta_file_buffer(1,63000112,constant,'function-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(127,1),line_char(127,15))). -user:metta_file_buffer(1,63000112,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(127,16),line_char(127,31))). -user:metta_file_buffer(1,63000112,number,1,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(127,32),line_char(127,33))). -user:metta_file_buffer(0,63000112,decl(impl),['function-arity','predicate-arity',1],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(127,0),line_char(127,34))). -user:metta_file_buffer(1,64000113,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(130,1),line_char(130,5))). -user:metta_file_buffer(1,64000113,constant,'function-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(130,6),line_char(130,20))). -user:metta_file_buffer(2,64000114,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(131,3),line_char(131,8))). -user:metta_file_buffer(2,64000114,string,"Defines the arity of a function, allowing predicates or built-in facts to also behave as callable functions. This enables procedural-style execution where the last argument of the predicate becomes the function's return value, and the system internally resolves the function using a `match` query. \n\nFor example:\n ; Declare the built-in predicate `max` with arity 2\n (predicate-arity max 2)\n\n ; Enable `max` as a function\n (add-atom &dyn-space (function-arity max 2))\n\n ; Define the rules for `max`\n (add-atom &dyn-space (max $X $Y $X) (<= $X $Y))\n (add-atom &dyn-space (max $X $Y $Y) (> $X $Y))\n\n ; Using `max` declaratively as a predicate\n (match &dyn-space (max (5 10) $max)\n (The maximum is $max))\n ; This resolves `$max = 10`.\n\n ; Using `max` procedurally as a function\n (max 5 10)\n ; Returns: 10.\n\n ; Reverse execution with `max`\n (max $pair 10)\n ; Returns: a pair such as (8 10) or (10 5) where the maximum is 10.\n\n This dual behavior allows predicates to act as functions, bridging procedural and declarative paradigms. By defining `function-arity`, the function automatically resolves using the logic of the associated predicate.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(131,9),line_char(157,218))). -user:metta_file_buffer(1,64000114,metta_other,['@desc',"Defines the arity of a function, allowing predicates or built-in facts to also behave as callable functions. This enables procedural-style execution where the last argument of the predicate becomes the function's return value, and the system internally resolves the function using a `match` query. \n\nFor example:\n ; Declare the built-in predicate `max` with arity 2\n (predicate-arity max 2)\n\n ; Enable `max` as a function\n (add-atom &dyn-space (function-arity max 2))\n\n ; Define the rules for `max`\n (add-atom &dyn-space (max $X $Y $X) (<= $X $Y))\n (add-atom &dyn-space (max $X $Y $Y) (> $X $Y))\n\n ; Using `max` declaratively as a predicate\n (match &dyn-space (max (5 10) $max)\n (The maximum is $max))\n ; This resolves `$max = 10`.\n\n ; Using `max` procedurally as a function\n (max 5 10)\n ; Returns: 10.\n\n ; Reverse execution with `max`\n (max $pair 10)\n ; Returns: a pair such as (8 10) or (10 5) where the maximum is 10.\n\n This dual behavior allows predicates to act as functions, bridging procedural and declarative paradigms. By defining `function-arity`, the function automatically resolves using the logic of the associated predicate."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(131,2),line_char(157,219))). -user:metta_file_buffer(2,64000115,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(158,3),line_char(158,10))). -user:metta_file_buffer(4,64000117,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(159,5),line_char(159,11))). -user:metta_file_buffer(4,64000117,string,"Function symbol",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(159,12),line_char(159,29))). -user:metta_file_buffer(4,64000117,string,"The name of the function or predicate to enable as a callable function.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(159,30),line_char(159,103))). -user:metta_file_buffer(3,64000117,metta_other,['@param',"Function symbol","The name of the function or predicate to enable as a callable function."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(159,4),line_char(159,104))). -user:metta_file_buffer(2,64000117,array,[['@param',"Function symbol","The name of the function or predicate to enable as a callable function."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(158,11),line_char(160,3))). -user:metta_file_buffer(1,64000117,metta_other,['@params',[['@param',"Function symbol","The name of the function or predicate to enable as a callable function."]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(158,2),line_char(160,4))). -user:metta_file_buffer(2,64000118,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(161,3),line_char(161,10))). -user:metta_file_buffer(2,64000118,string,"The number of arguments expected by the function.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(161,11),line_char(161,62))). -user:metta_file_buffer(1,64000118,metta_other,['@return',"The number of arguments expected by the function."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(161,2),line_char(161,63))). -user:metta_file_buffer(0,64000118,decl(doc),['@doc','function-arity',['@desc',"Defines the arity of a function, allowing predicates or built-in facts to also behave as callable functions. This enables procedural-style execution where the last argument of the predicate becomes the function's return value, and the system internally resolves the function using a `match` query. \n\nFor example:\n ; Declare the built-in predicate `max` with arity 2\n (predicate-arity max 2)\n\n ; Enable `max` as a function\n (add-atom &dyn-space (function-arity max 2))\n\n ; Define the rules for `max`\n (add-atom &dyn-space (max $X $Y $X) (<= $X $Y))\n (add-atom &dyn-space (max $X $Y $Y) (> $X $Y))\n\n ; Using `max` declaratively as a predicate\n (match &dyn-space (max (5 10) $max)\n (The maximum is $max))\n ; This resolves `$max = 10`.\n\n ; Using `max` procedurally as a function\n (max 5 10)\n ; Returns: 10.\n\n ; Reverse execution with `max`\n (max $pair 10)\n ; Returns: a pair such as (8 10) or (10 5) where the maximum is 10.\n\n This dual behavior allows predicates to act as functions, bridging procedural and declarative paradigms. By defining `function-arity`, the function automatically resolves using the logic of the associated predicate."],['@params',[['@param',"Function symbol","The name of the function or predicate to enable as a callable function."]]],['@return',"The number of arguments expected by the function."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(130,0),line_char(161,64))). -user:metta_file_buffer(1,65000119,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(162,1),line_char(162,2))). -user:metta_file_buffer(1,65000119,constant,'function-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(162,3),line_char(162,17))). -user:metta_file_buffer(2,65000120,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(162,19),line_char(162,21))). -user:metta_file_buffer(2,65000120,constant,'Symbol',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(162,22),line_char(162,28))). -user:metta_file_buffer(2,65000120,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(162,29),line_char(162,35))). -user:metta_file_buffer(1,65000120,metta_other,[->,'Symbol','Number'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(162,18),line_char(162,36))). -user:metta_file_buffer(0,65000120,decl(ftype),[:,'function-arity',[->,'Symbol','Number']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(162,0),line_char(162,37))). -user:metta_file_buffer(1,66000121,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(163,1),line_char(163,16))). -user:metta_file_buffer(1,66000121,constant,'function-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(163,17),line_char(163,31))). -user:metta_file_buffer(1,66000121,number,2,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(163,32),line_char(163,33))). -user:metta_file_buffer(0,66000121,decl(impl),['predicate-arity','function-arity',2],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(163,0),line_char(163,34))). -user:metta_file_buffer(1,67000122,constant,'function-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(164,1),line_char(164,15))). -user:metta_file_buffer(1,67000122,constant,'function-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(164,16),line_char(164,30))). -user:metta_file_buffer(1,67000122,number,1,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(164,31),line_char(164,32))). -user:metta_file_buffer(0,67000122,decl(impl),['function-arity','function-arity',1],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(164,0),line_char(164,33))). -user:metta_file_buffer(0,68000122,indexed(metta_comment,";; If Function"),'$COMMENT'(";; If Function",166,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(166,0),line_char(166,14))). -user:metta_file_buffer(1,68000123,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(168,1),line_char(168,3))). -user:metta_file_buffer(1,68000123,constant,'If',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(168,4),line_char(168,6))). -user:metta_file_buffer(1,68000123,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(168,7),line_char(168,12))). -user:metta_file_buffer(0,68000123,decl(impl),[iz,'If','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(168,0),line_char(168,13))). -user:metta_file_buffer(1,69000124,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(169,1),line_char(169,5))). -user:metta_file_buffer(1,69000124,constant,'If',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(169,6),line_char(169,8))). -user:metta_file_buffer(2,69000125,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(170,3),line_char(170,8))). -user:metta_file_buffer(2,69000125,string,"Conditional function that evaluates and returns one of the provided atoms based on a boolean condition.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(170,9),line_char(170,114))). -user:metta_file_buffer(1,69000125,metta_other,['@desc',"Conditional function that evaluates and returns one of the provided atoms based on a boolean condition."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(170,2),line_char(170,115))). -user:metta_file_buffer(2,69000126,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(171,3),line_char(171,10))). -user:metta_file_buffer(4,69000128,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(172,5),line_char(172,11))). -user:metta_file_buffer(4,69000128,string,"Boolean condition",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(172,12),line_char(172,31))). -user:metta_file_buffer(3,69000128,metta_other,['@param',"Boolean condition"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(172,4),line_char(172,32))). -user:metta_file_buffer(4,69000129,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(173,5),line_char(173,11))). -user:metta_file_buffer(4,69000129,string,"Atom to return if condition is True",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(173,12),line_char(173,49))). -user:metta_file_buffer(3,69000129,metta_other,['@param',"Atom to return if condition is True"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(173,4),line_char(173,50))). -user:metta_file_buffer(4,69000130,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(174,5),line_char(174,11))). -user:metta_file_buffer(4,69000130,string,"Atom to return if condition is False (optional)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(174,12),line_char(174,61))). -user:metta_file_buffer(3,69000130,metta_other,['@param',"Atom to return if condition is False (optional)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(174,4),line_char(174,62))). -user:metta_file_buffer(2,69000130,array,[['@param',"Boolean condition"],['@param',"Atom to return if condition is True"],['@param',"Atom to return if condition is False (optional)"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(171,11),line_char(174,63))). -user:metta_file_buffer(1,69000130,metta_other,['@params',[['@param',"Boolean condition"],['@param',"Atom to return if condition is True"],['@param',"Atom to return if condition is False (optional)"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(171,2),line_char(174,64))). -user:metta_file_buffer(2,69000131,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(175,3),line_char(175,10))). -user:metta_file_buffer(2,69000131,string,"Either the second or third argument depending on the condition",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(175,11),line_char(175,75))). -user:metta_file_buffer(1,69000131,metta_other,['@return',"Either the second or third argument depending on the condition"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(175,2),line_char(175,76))). -user:metta_file_buffer(0,69000131,decl(doc),['@doc','If',['@desc',"Conditional function that evaluates and returns one of the provided atoms based on a boolean condition."],['@params',[['@param',"Boolean condition"],['@param',"Atom to return if condition is True"],['@param',"Atom to return if condition is False (optional)"]]],['@return',"Either the second or third argument depending on the condition"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(169,0),line_char(175,77))). -user:metta_file_buffer(1,70000132,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(176,1),line_char(176,2))). -user:metta_file_buffer(1,70000132,constant,'If',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(176,3),line_char(176,5))). -user:metta_file_buffer(2,70000133,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(176,7),line_char(176,9))). -user:metta_file_buffer(2,70000133,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(176,10),line_char(176,14))). -user:metta_file_buffer(2,70000133,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(176,15),line_char(176,19))). -user:metta_file_buffer(2,70000133,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(176,20),line_char(176,24))). -user:metta_file_buffer(2,70000133,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(176,25),line_char(176,29))). -user:metta_file_buffer(1,70000133,metta_other,[->,'Bool','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(176,6),line_char(176,30))). -user:metta_file_buffer(0,70000133,decl(ftype),[:,'If',[->,'Bool','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(176,0),line_char(176,31))). -user:metta_file_buffer(1,71000134,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(177,1),line_char(177,2))). -user:metta_file_buffer(1,71000134,constant,'If',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(177,3),line_char(177,5))). -user:metta_file_buffer(2,71000135,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(177,7),line_char(177,9))). -user:metta_file_buffer(2,71000135,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(177,10),line_char(177,14))). -user:metta_file_buffer(2,71000135,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(177,15),line_char(177,19))). -user:metta_file_buffer(2,71000135,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(177,20),line_char(177,24))). -user:metta_file_buffer(1,71000135,metta_other,[->,'Bool','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(177,6),line_char(177,25))). -user:metta_file_buffer(0,71000135,decl(ftype),[:,'If',[->,'Bool','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(177,0),line_char(177,26))). -user:metta_file_buffer(1,72000136,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(178,1),line_char(178,2))). -user:metta_file_buffer(2,72000137,constant,'If',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(178,4),line_char(178,6))). -user:metta_file_buffer(2,72000137,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(178,7),line_char(178,11))). -user:metta_file_buffer(2,72000137,variable,_46192,['_then'=_46192],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(178,12),line_char(178,17))). -user:metta_file_buffer(1,72000137,indexed(metta_other,['If','True',_47040]),['If','True',_47098],['_then'=_47098],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(178,3),line_char(178,18))). -user:metta_file_buffer(1,72000137,variable,_48078,['_then'=_48078],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(178,19),line_char(178,24))). -user:metta_file_buffer(0,72000137,indexed(decl(impl),['If','True',_48942]),[=,['If','True',_49030],_49030],['_then'=_49030],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(178,0),line_char(178,25))). -user:metta_file_buffer(1,73000138,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,1),line_char(179,2))). -user:metta_file_buffer(2,73000139,constant,'If',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,4),line_char(179,6))). -user:metta_file_buffer(2,73000139,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,7),line_char(179,12))). -user:metta_file_buffer(2,73000139,variable,_46202,['_then'=_46202],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,13),line_char(179,18))). -user:metta_file_buffer(1,73000139,indexed(metta_other,['If','False',_47050]),['If','False',_47108],['_then'=_47108],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,3),line_char(179,19))). -user:metta_file_buffer(2,73000140,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,21),line_char(179,24))). -user:metta_file_buffer(2,73000140,variable,_48816,['_n'=_48816],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,25),line_char(179,27))). -user:metta_file_buffer(2,73000140,number,0,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,28),line_char(179,29))). -user:metta_file_buffer(3,73000141,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,31),line_char(179,34))). -user:metta_file_buffer(3,73000141,variable,_51462,['_n'=_51462],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,35),line_char(179,37))). -user:metta_file_buffer(3,73000141,number,1,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,38),line_char(179,39))). -user:metta_file_buffer(3,73000141,variable,_53332,['_n'=_53332],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,40),line_char(179,42))). -user:metta_file_buffer(2,73000141,indexed(metta_other,[let,_54178,1,_54178]),[let,_54256,1,_54256],['_n'=_54256],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,30),line_char(179,43))). -user:metta_file_buffer(1,73000141,indexed(metta_other,[let,_54802,0,[let,_54802,1,_54802]]),[let,_54922,0,[let,_54922,1,_54922]],['_n'=_54922],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,20),line_char(179,44))). -user:metta_file_buffer(0,73000141,indexed(decl(impl),['If','False',_55510]),[=,['If','False',_55686],[let,_55704,0,[let,_55704,1,_55704]]],['_n'=_55704,'_then'=_55686],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,0),line_char(179,45))). -user:metta_file_buffer(0,74000141,indexed(metta_comment,"; Placeholder for False condition"),'$COMMENT'("; Placeholder for False condition",179,46),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(179,46),line_char(179,79))). -user:metta_file_buffer(1,74000142,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(180,1),line_char(180,2))). -user:metta_file_buffer(2,74000143,constant,'If',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(180,4),line_char(180,6))). -user:metta_file_buffer(2,74000143,variable,_46202,['_cond'=_46202],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(180,7),line_char(180,12))). -user:metta_file_buffer(2,74000143,variable,_47486,['_then'=_47486],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(180,13),line_char(180,18))). -user:metta_file_buffer(2,74000143,variable,_48778,['_else'=_48778],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(180,19),line_char(180,24))). -user:metta_file_buffer(1,74000143,indexed(metta_other,['If',_49624,_49646,_49668]),['If',_49720,_49726,_49732],['_else'=_49732,'_then'=_49726,'_cond'=_49720],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(180,3),line_char(180,25))). -user:metta_file_buffer(2,74000144,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(180,27),line_char(180,29))). -user:metta_file_buffer(2,74000144,variable,_51502,['_cond'=_51502],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(180,30),line_char(180,35))). -user:metta_file_buffer(2,74000144,variable,_52786,['_then'=_52786],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(180,36),line_char(180,41))). -user:metta_file_buffer(2,74000144,variable,_54078,['_else'=_54078],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(180,42),line_char(180,47))). -user:metta_file_buffer(1,74000144,indexed(metta_other,[if,_54924,_54946,_54968]),[if,_55020,_55026,_55032],['_else'=_55032,'_then'=_55026,'_cond'=_55020],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(180,26),line_char(180,48))). -user:metta_file_buffer(0,74000144,indexed(decl(impl),['If',_55600,_55622,_55644]),[=,['If',_55778,_55784,_55790],[if,_55778,_55784,_55790]],['_else'=_55790,'_then'=_55784,'_cond'=_55778],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(180,0),line_char(180,49))). -user:metta_file_buffer(0,75000144,indexed(metta_comment,";; Arity Assignments"),'$COMMENT'(";; Arity Assignments",182,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(182,0),line_char(182,20))). -user:metta_file_buffer(1,75000145,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(184,1),line_char(184,16))). -user:metta_file_buffer(1,75000145,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(184,17),line_char(184,32))). -user:metta_file_buffer(1,75000145,number,2,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(184,33),line_char(184,34))). -user:metta_file_buffer(0,75000145,decl(impl),['predicate-arity','predicate-arity',2],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(184,0),line_char(184,35))). -user:metta_file_buffer(1,76000146,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(185,1),line_char(185,16))). -user:metta_file_buffer(1,76000146,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(185,17),line_char(185,18))). -user:metta_file_buffer(1,76000146,number,2,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(185,19),line_char(185,20))). -user:metta_file_buffer(0,76000146,decl(impl),['predicate-arity',:,2],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(185,0),line_char(185,21))). -user:metta_file_buffer(1,77000147,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(186,1),line_char(186,2))). -user:metta_file_buffer(2,77000148,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(186,4),line_char(186,5))). -user:metta_file_buffer(2,77000148,variable,_45310,['F'=_45310],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(186,6),line_char(186,8))). -user:metta_file_buffer(2,77000148,constant,'P1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(186,9),line_char(186,11))). -user:metta_file_buffer(1,77000148,indexed(metta_typedecl,[:,_46726,'P1']),[:,_46786,'P1'],['F'=_46786],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(186,3),line_char(186,12))). -user:metta_file_buffer(2,77000149,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(186,14),line_char(186,29))). -user:metta_file_buffer(2,77000149,variable,_48262,['F'=_48262],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(186,30),line_char(186,32))). -user:metta_file_buffer(2,77000149,number,1,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(186,33),line_char(186,34))). -user:metta_file_buffer(1,77000149,indexed(metta_other,['predicate-arity',_49736,1]),['predicate-arity',_49796,1],['F'=_49796],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(186,13),line_char(186,35))). -user:metta_file_buffer(0,77000149,indexed(decl(impl),[:,_50340,'P1']),[=,[:,_50454,'P1'],['predicate-arity',_50454,1]],['F'=_50454],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(186,0),line_char(186,36))). -user:metta_file_buffer(0,78000149,indexed(metta_comment,";; Source Predicate and Function Types"),'$COMMENT'(";; Source Predicate and Function Types",188,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(188,0),line_char(188,38))). -user:metta_file_buffer(1,78000150,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(190,1),line_char(190,3))). -user:metta_file_buffer(1,78000150,constant,'SrcPredicate',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(190,4),line_char(190,16))). -user:metta_file_buffer(1,78000150,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(190,17),line_char(190,22))). -user:metta_file_buffer(0,78000150,decl(impl),[iz,'SrcPredicate','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(190,0),line_char(190,23))). -user:metta_file_buffer(1,79000151,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(191,1),line_char(191,5))). -user:metta_file_buffer(1,79000151,constant,'SrcPredicate',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(191,6),line_char(191,18))). -user:metta_file_buffer(2,79000152,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(192,3),line_char(192,8))). -user:metta_file_buffer(2,79000152,string,"Type representing a source predicate.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(192,9),line_char(192,48))). -user:metta_file_buffer(1,79000152,metta_other,['@desc',"Type representing a source predicate."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(192,2),line_char(192,49))). -user:metta_file_buffer(0,79000152,decl(doc),['@doc','SrcPredicate',['@desc',"Type representing a source predicate."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(191,0),line_char(192,50))). -user:metta_file_buffer(1,80000153,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(193,1),line_char(193,2))). -user:metta_file_buffer(1,80000153,constant,'SrcPredicate',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(193,3),line_char(193,15))). -user:metta_file_buffer(1,80000153,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(193,16),line_char(193,20))). -user:metta_file_buffer(0,80000153,decl(ftype),[:,'SrcPredicate','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(193,0),line_char(193,21))). -user:metta_file_buffer(1,81000154,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(195,1),line_char(195,3))). -user:metta_file_buffer(1,81000154,constant,'SrcFunction',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(195,4),line_char(195,15))). -user:metta_file_buffer(1,81000154,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(195,16),line_char(195,21))). -user:metta_file_buffer(0,81000154,decl(impl),[iz,'SrcFunction','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(195,0),line_char(195,22))). -user:metta_file_buffer(1,82000155,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(196,1),line_char(196,5))). -user:metta_file_buffer(1,82000155,constant,'SrcFunction',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(196,6),line_char(196,17))). -user:metta_file_buffer(2,82000156,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(197,3),line_char(197,8))). -user:metta_file_buffer(2,82000156,string,"Type representing a source function.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(197,9),line_char(197,47))). -user:metta_file_buffer(1,82000156,metta_other,['@desc',"Type representing a source function."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(197,2),line_char(197,48))). -user:metta_file_buffer(0,82000156,decl(doc),['@doc','SrcFunction',['@desc',"Type representing a source function."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(196,0),line_char(197,49))). -user:metta_file_buffer(1,83000157,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(198,1),line_char(198,2))). -user:metta_file_buffer(1,83000157,constant,'SrcFunction',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(198,3),line_char(198,14))). -user:metta_file_buffer(1,83000157,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(198,15),line_char(198,19))). -user:metta_file_buffer(0,83000157,decl(ftype),[:,'SrcFunction','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(198,0),line_char(198,20))). -user:metta_file_buffer(0,84000157,indexed(metta_comment,";; MeTTaResult Type and Values"),'$COMMENT'(";; MeTTaResult Type and Values",200,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(200,0),line_char(200,30))). -user:metta_file_buffer(1,84000158,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(202,1),line_char(202,3))). -user:metta_file_buffer(1,84000158,constant,'MeTTaResult',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(202,4),line_char(202,15))). -user:metta_file_buffer(1,84000158,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(202,16),line_char(202,21))). -user:metta_file_buffer(0,84000158,decl(impl),[iz,'MeTTaResult','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(202,0),line_char(202,22))). -user:metta_file_buffer(1,85000159,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(203,1),line_char(203,5))). -user:metta_file_buffer(1,85000159,constant,'MeTTaResult',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(203,6),line_char(203,17))). -user:metta_file_buffer(2,85000160,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(204,3),line_char(204,8))). -user:metta_file_buffer(2,85000160,string,"Type representing the result of a MeTTa evaluation.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(204,9),line_char(204,62))). -user:metta_file_buffer(1,85000160,metta_other,['@desc',"Type representing the result of a MeTTa evaluation."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(204,2),line_char(204,63))). -user:metta_file_buffer(0,85000160,decl(doc),['@doc','MeTTaResult',['@desc',"Type representing the result of a MeTTa evaluation."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(203,0),line_char(204,64))). -user:metta_file_buffer(1,86000161,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(205,1),line_char(205,2))). -user:metta_file_buffer(1,86000161,constant,'MeTTaResult',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(205,3),line_char(205,14))). -user:metta_file_buffer(1,86000161,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(205,15),line_char(205,19))). -user:metta_file_buffer(0,86000161,decl(ftype),[:,'MeTTaResult','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(205,0),line_char(205,20))). -user:metta_file_buffer(1,87000162,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(207,1),line_char(207,3))). -user:metta_file_buffer(1,87000162,constant,'NotReducible',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(207,4),line_char(207,16))). -user:metta_file_buffer(1,87000162,constant,'MeTTaResult',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(207,17),line_char(207,28))). -user:metta_file_buffer(0,87000162,decl(impl),[iz,'NotReducible','MeTTaResult'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(207,0),line_char(207,29))). -user:metta_file_buffer(1,88000163,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(208,1),line_char(208,5))). -user:metta_file_buffer(1,88000163,constant,'NotReducible',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(208,6),line_char(208,18))). -user:metta_file_buffer(2,88000164,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(209,3),line_char(209,8))). -user:metta_file_buffer(2,88000164,string,"Result indicating that an atom cannot be reduced further.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(209,9),line_char(209,68))). -user:metta_file_buffer(1,88000164,metta_other,['@desc',"Result indicating that an atom cannot be reduced further."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(209,2),line_char(209,69))). -user:metta_file_buffer(0,88000164,decl(doc),['@doc','NotReducible',['@desc',"Result indicating that an atom cannot be reduced further."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(208,0),line_char(209,70))). -user:metta_file_buffer(1,89000165,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(210,1),line_char(210,2))). -user:metta_file_buffer(1,89000165,constant,'NotReducible',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(210,3),line_char(210,15))). -user:metta_file_buffer(1,89000165,constant,'MeTTaResult',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(210,16),line_char(210,27))). -user:metta_file_buffer(0,89000165,decl(ftype),[:,'NotReducible','MeTTaResult'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(210,0),line_char(210,28))). -user:metta_file_buffer(1,90000166,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(212,1),line_char(212,3))). -user:metta_file_buffer(1,90000166,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(212,4),line_char(212,9))). -user:metta_file_buffer(1,90000166,constant,'MeTTaResult',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(212,10),line_char(212,21))). -user:metta_file_buffer(0,90000166,decl(impl),[iz,'Empty','MeTTaResult'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(212,0),line_char(212,22))). -user:metta_file_buffer(1,91000167,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(213,1),line_char(213,5))). -user:metta_file_buffer(1,91000167,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(213,6),line_char(213,11))). -user:metta_file_buffer(2,91000168,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(214,3),line_char(214,8))). -user:metta_file_buffer(2,91000168,string,"Result indicating an empty evaluation result.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(214,9),line_char(214,56))). -user:metta_file_buffer(1,91000168,metta_other,['@desc',"Result indicating an empty evaluation result."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(214,2),line_char(214,57))). -user:metta_file_buffer(0,91000168,decl(doc),['@doc','Empty',['@desc',"Result indicating an empty evaluation result."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(213,0),line_char(214,58))). -user:metta_file_buffer(1,92000169,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(215,1),line_char(215,2))). -user:metta_file_buffer(1,92000169,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(215,3),line_char(215,8))). -user:metta_file_buffer(1,92000169,constant,'MeTTaResult',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(215,9),line_char(215,20))). -user:metta_file_buffer(0,92000169,decl(ftype),[:,'Empty','MeTTaResult'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(215,0),line_char(215,21))). -user:metta_file_buffer(0,93000169,indexed(metta_comment,";; Subtype Relations"),'$COMMENT'(";; Subtype Relations",217,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(217,0),line_char(217,20))). -user:metta_file_buffer(1,93000170,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(219,1),line_char(219,3))). -user:metta_file_buffer(1,93000170,constant,'ValueAtom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(219,4),line_char(219,13))). -user:metta_file_buffer(1,93000170,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(219,14),line_char(219,19))). -user:metta_file_buffer(0,93000170,decl(impl),[iz,'ValueAtom','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(219,0),line_char(219,20))). -user:metta_file_buffer(1,94000171,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(220,1),line_char(220,5))). -user:metta_file_buffer(1,94000171,constant,'ValueAtom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(220,6),line_char(220,15))). -user:metta_file_buffer(2,94000172,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(221,3),line_char(221,8))). -user:metta_file_buffer(2,94000172,string,"Type representing a value atom.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(221,9),line_char(221,42))). -user:metta_file_buffer(1,94000172,metta_other,['@desc',"Type representing a value atom."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(221,2),line_char(221,43))). -user:metta_file_buffer(0,94000172,decl(doc),['@doc','ValueAtom',['@desc',"Type representing a value atom."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(220,0),line_char(221,44))). -user:metta_file_buffer(1,95000173,constant,:>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(222,1),line_char(222,3))). -user:metta_file_buffer(1,95000173,constant,'ValueAtom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(222,4),line_char(222,13))). -user:metta_file_buffer(1,95000173,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(222,14),line_char(222,18))). -user:metta_file_buffer(0,95000173,decl(impl),[:>,'ValueAtom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(222,0),line_char(222,19))). -user:metta_file_buffer(1,96000174,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(224,1),line_char(224,3))). -user:metta_file_buffer(1,96000174,constant,'ForeignObject',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(224,4),line_char(224,17))). -user:metta_file_buffer(1,96000174,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(224,18),line_char(224,23))). -user:metta_file_buffer(0,96000174,decl(impl),[iz,'ForeignObject','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(224,0),line_char(224,24))). -user:metta_file_buffer(1,97000175,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(225,1),line_char(225,5))). -user:metta_file_buffer(1,97000175,constant,'ForeignObject',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(225,6),line_char(225,19))). -user:metta_file_buffer(2,97000176,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(226,3),line_char(226,8))). -user:metta_file_buffer(2,97000176,string,"Type representing a foreign object, such as a Python object.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(226,9),line_char(226,71))). -user:metta_file_buffer(1,97000176,metta_other,['@desc',"Type representing a foreign object, such as a Python object."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(226,2),line_char(226,72))). -user:metta_file_buffer(0,97000176,decl(doc),['@doc','ForeignObject',['@desc',"Type representing a foreign object, such as a Python object."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(225,0),line_char(226,73))). -user:metta_file_buffer(1,98000177,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(227,1),line_char(227,2))). -user:metta_file_buffer(1,98000177,constant,'ForeignObject',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(227,3),line_char(227,16))). -user:metta_file_buffer(1,98000177,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(227,17),line_char(227,21))). -user:metta_file_buffer(0,98000177,decl(ftype),[:,'ForeignObject','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(227,0),line_char(227,22))). -user:metta_file_buffer(1,99000178,constant,:>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(229,1),line_char(229,3))). -user:metta_file_buffer(1,99000178,constant,'ValueAtom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(229,4),line_char(229,13))). -user:metta_file_buffer(1,99000178,constant,'Grounded',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(229,14),line_char(229,22))). -user:metta_file_buffer(0,99000178,decl(impl),[:>,'ValueAtom','Grounded'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(229,0),line_char(229,23))). -user:metta_file_buffer(1,100000179,constant,:>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(230,1),line_char(230,3))). -user:metta_file_buffer(1,100000179,constant,'ForeignObject',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(230,4),line_char(230,17))). -user:metta_file_buffer(1,100000179,constant,'ValueAtom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(230,18),line_char(230,27))). -user:metta_file_buffer(0,100000179,decl(impl),[:>,'ForeignObject','ValueAtom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(230,0),line_char(230,28))). -user:metta_file_buffer(1,101000180,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(232,1),line_char(232,3))). -user:metta_file_buffer(1,101000180,constant,'PyObject',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(232,4),line_char(232,12))). -user:metta_file_buffer(1,101000180,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(232,13),line_char(232,18))). -user:metta_file_buffer(0,101000180,decl(impl),[iz,'PyObject','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(232,0),line_char(232,19))). -user:metta_file_buffer(1,102000181,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(233,1),line_char(233,5))). -user:metta_file_buffer(1,102000181,constant,'PyObject',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(233,6),line_char(233,14))). -user:metta_file_buffer(2,102000182,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(234,3),line_char(234,8))). -user:metta_file_buffer(2,102000182,string,"Type representing a Python object.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(234,9),line_char(234,45))). -user:metta_file_buffer(1,102000182,metta_other,['@desc',"Type representing a Python object."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(234,2),line_char(234,46))). -user:metta_file_buffer(0,102000182,decl(doc),['@doc','PyObject',['@desc',"Type representing a Python object."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(233,0),line_char(234,47))). -user:metta_file_buffer(1,103000183,constant,:>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(235,1),line_char(235,3))). -user:metta_file_buffer(1,103000183,constant,'PyObject',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(235,4),line_char(235,12))). -user:metta_file_buffer(1,103000183,constant,'ForeignObject',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(235,13),line_char(235,26))). -user:metta_file_buffer(0,103000183,decl(impl),[:>,'PyObject','ForeignObject'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(235,0),line_char(235,27))). -user:metta_file_buffer(0,104000183,indexed(metta_comment,";; Space Subtype Relation"),'$COMMENT'(";; Space Subtype Relation",237,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(237,0),line_char(237,25))). -user:metta_file_buffer(1,104000184,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(239,1),line_char(239,5))). -user:metta_file_buffer(1,104000184,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(239,6),line_char(239,30))). -user:metta_file_buffer(2,104000185,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(240,3),line_char(240,8))). -user:metta_file_buffer(2,104000185,string,"Dynamic space type, representing an Atomspace.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(240,9),line_char(240,57))). -user:metta_file_buffer(1,104000185,metta_other,['@desc',"Dynamic space type, representing an Atomspace."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(240,2),line_char(240,58))). -user:metta_file_buffer(0,104000185,decl(doc),['@doc','hyperon::space::DynSpace',['@desc',"Dynamic space type, representing an Atomspace."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(239,0),line_char(240,59))). -user:metta_file_buffer(1,105000186,constant,:>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(241,1),line_char(241,3))). -user:metta_file_buffer(1,105000186,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(241,4),line_char(241,28))). -user:metta_file_buffer(1,105000186,constant,'Grounded',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(241,29),line_char(241,37))). -user:metta_file_buffer(0,105000186,decl(impl),[:>,'hyperon::space::DynSpace','Grounded'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(241,0),line_char(241,38))). -user:metta_file_buffer(1,106000187,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(245,1),line_char(245,3))). -user:metta_file_buffer(1,106000187,constant,'py-list',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(245,4),line_char(245,11))). -user:metta_file_buffer(1,106000187,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(245,12),line_char(245,17))). -user:metta_file_buffer(0,106000187,decl(impl),[iz,'py-list','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(245,0),line_char(245,18))). -user:metta_file_buffer(1,107000188,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(246,1),line_char(246,5))). -user:metta_file_buffer(1,107000188,constant,'py-list',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(246,6),line_char(246,13))). -user:metta_file_buffer(2,107000189,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(247,3),line_char(247,8))). -user:metta_file_buffer(2,107000189,string,"Converts a MeTTa Expression into a Python list and returns it as a PyObject.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(247,9),line_char(247,87))). -user:metta_file_buffer(1,107000189,metta_other,['@desc',"Converts a MeTTa Expression into a Python list and returns it as a PyObject."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(247,2),line_char(247,88))). -user:metta_file_buffer(2,107000190,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(248,3),line_char(248,10))). -user:metta_file_buffer(4,107000192,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(249,5),line_char(249,11))). -user:metta_file_buffer(5,107000193,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(249,13),line_char(249,18))). -user:metta_file_buffer(5,107000193,string,"A MeTTa List that will be converted into a Python list",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(249,19),line_char(249,75))). -user:metta_file_buffer(4,107000193,metta_other,['@desc',"A MeTTa List that will be converted into a Python list"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(249,12),line_char(249,76))). -user:metta_file_buffer(3,107000193,metta_other,['@param',['@desc',"A MeTTa List that will be converted into a Python list"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(249,4),line_char(249,77))). -user:metta_file_buffer(2,107000193,array,[['@param',['@desc',"A MeTTa List that will be converted into a Python list"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(248,11),line_char(250,3))). -user:metta_file_buffer(1,107000193,metta_other,['@params',[['@param',['@desc',"A MeTTa List that will be converted into a Python list"]]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(248,2),line_char(250,4))). -user:metta_file_buffer(2,107000194,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(251,3),line_char(251,10))). -user:metta_file_buffer(3,107000195,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(251,12),line_char(251,17))). -user:metta_file_buffer(3,107000195,string,"A Python list object that represents the given MeTTa Expression as a PyObject",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(251,18),line_char(251,97))). -user:metta_file_buffer(2,107000195,metta_other,['@desc',"A Python list object that represents the given MeTTa Expression as a PyObject"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(251,11),line_char(251,98))). -user:metta_file_buffer(1,107000195,metta_other,['@return',['@desc',"A Python list object that represents the given MeTTa Expression as a PyObject"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(251,2),line_char(251,99))). -user:metta_file_buffer(0,107000195,decl(doc),['@doc','py-list',['@desc',"Converts a MeTTa Expression into a Python list and returns it as a PyObject."],['@params',[['@param',['@desc',"A MeTTa List that will be converted into a Python list"]]]],['@return',['@desc',"A Python list object that represents the given MeTTa Expression as a PyObject"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(246,0),line_char(252,1))). -user:metta_file_buffer(1,108000196,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(253,1),line_char(253,2))). -user:metta_file_buffer(1,108000196,constant,'py-list',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(253,3),line_char(253,10))). -user:metta_file_buffer(2,108000197,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(253,12),line_char(253,14))). -user:metta_file_buffer(2,108000197,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(253,15),line_char(253,25))). -user:metta_file_buffer(2,108000197,constant,'PyObject',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(253,26),line_char(253,34))). -user:metta_file_buffer(1,108000197,metta_other,[->,'Expression','PyObject'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(253,11),line_char(253,35))). -user:metta_file_buffer(0,108000197,decl(ftype),[:,'py-list',[->,'Expression','PyObject']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(253,0),line_char(253,36))). -user:metta_file_buffer(1,109000198,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(255,1),line_char(255,3))). -user:metta_file_buffer(1,109000198,constant,'py-chain',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(255,4),line_char(255,12))). -user:metta_file_buffer(1,109000198,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(255,13),line_char(255,18))). -user:metta_file_buffer(0,109000198,decl(impl),[iz,'py-chain','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(255,0),line_char(255,19))). -user:metta_file_buffer(1,110000199,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(256,1),line_char(256,5))). -user:metta_file_buffer(1,110000199,constant,'py-chain',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(256,6),line_char(256,14))). -user:metta_file_buffer(2,110000200,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(257,3),line_char(257,8))). -user:metta_file_buffer(2,110000200,string,"Chains together a list of Python objects contained in a MeTTa Expression, applying the Python vertical bar | OR operation jointly to all elements.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(257,9),line_char(257,157))). -user:metta_file_buffer(1,110000200,metta_other,['@desc',"Chains together a list of Python objects contained in a MeTTa Expression, applying the Python vertical bar | OR operation jointly to all elements."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(257,2),line_char(257,158))). -user:metta_file_buffer(2,110000201,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(258,3),line_char(258,10))). -user:metta_file_buffer(4,110000203,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(259,5),line_char(259,11))). -user:metta_file_buffer(5,110000204,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(259,13),line_char(259,18))). -user:metta_file_buffer(5,110000204,string,"A MeTTa list of atoms, each embedding a Python object.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(259,19),line_char(259,75))). -user:metta_file_buffer(4,110000204,metta_other,['@desc',"A MeTTa list of atoms, each embedding a Python object."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(259,12),line_char(259,76))). -user:metta_file_buffer(3,110000204,metta_other,['@param',['@desc',"A MeTTa list of atoms, each embedding a Python object."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(259,4),line_char(259,77))). -user:metta_file_buffer(2,110000204,array,[['@param',['@desc',"A MeTTa list of atoms, each embedding a Python object."]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(258,11),line_char(260,3))). -user:metta_file_buffer(1,110000204,metta_other,['@params',[['@param',['@desc',"A MeTTa list of atoms, each embedding a Python object."]]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(258,2),line_char(260,4))). -user:metta_file_buffer(2,110000205,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(261,3),line_char(261,10))). -user:metta_file_buffer(3,110000206,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(261,12),line_char(261,17))). -user:metta_file_buffer(3,110000206,string,"A MeTTa atom which embeds the result of applying the Python OR | operator to all elements of the list.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(261,18),line_char(261,122))). -user:metta_file_buffer(2,110000206,metta_other,['@desc',"A MeTTa atom which embeds the result of applying the Python OR | operator to all elements of the list."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(261,11),line_char(261,123))). -user:metta_file_buffer(1,110000206,metta_other,['@return',['@desc',"A MeTTa atom which embeds the result of applying the Python OR | operator to all elements of the list."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(261,2),line_char(261,124))). -user:metta_file_buffer(0,110000206,decl(doc),['@doc','py-chain',['@desc',"Chains together a list of Python objects contained in a MeTTa Expression, applying the Python vertical bar | OR operation jointly to all elements."],['@params',[['@param',['@desc',"A MeTTa list of atoms, each embedding a Python object."]]]],['@return',['@desc',"A MeTTa atom which embeds the result of applying the Python OR | operator to all elements of the list."]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(256,0),line_char(262,1))). -user:metta_file_buffer(1,111000207,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(263,1),line_char(263,2))). -user:metta_file_buffer(1,111000207,constant,'py-chain',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(263,3),line_char(263,11))). -user:metta_file_buffer(2,111000208,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(263,13),line_char(263,15))). -user:metta_file_buffer(2,111000208,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(263,16),line_char(263,26))). -user:metta_file_buffer(2,111000208,constant,'PyObject',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(263,27),line_char(263,35))). -user:metta_file_buffer(1,111000208,metta_other,[->,'Expression','PyObject'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(263,12),line_char(263,36))). -user:metta_file_buffer(0,111000208,decl(ftype),[:,'py-chain',[->,'Expression','PyObject']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(263,0),line_char(263,37))). -user:metta_file_buffer(1,112000209,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(265,1),line_char(265,3))). -user:metta_file_buffer(1,112000209,constant,'py-eval',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(265,4),line_char(265,11))). -user:metta_file_buffer(1,112000209,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(265,12),line_char(265,20))). -user:metta_file_buffer(0,112000209,decl(impl),[iz,'py-eval','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(265,0),line_char(265,21))). -user:metta_file_buffer(1,113000210,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(266,1),line_char(266,5))). -user:metta_file_buffer(1,113000210,constant,'py-eval',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(266,6),line_char(266,13))). -user:metta_file_buffer(2,113000211,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(267,3),line_char(267,8))). -user:metta_file_buffer(2,113000211,string,"Evaluates a Python expression from a string and returns the result as a PyObject.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(267,9),line_char(267,92))). -user:metta_file_buffer(1,113000211,metta_other,['@desc',"Evaluates a Python expression from a string and returns the result as a PyObject."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(267,2),line_char(267,93))). -user:metta_file_buffer(2,113000212,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(268,3),line_char(268,10))). -user:metta_file_buffer(4,113000214,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(269,5),line_char(269,11))). -user:metta_file_buffer(5,113000215,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(269,13),line_char(269,18))). -user:metta_file_buffer(5,113000215,string,"A string representing a Python expression that will be evaluated",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(269,19),line_char(269,85))). -user:metta_file_buffer(4,113000215,metta_other,['@desc',"A string representing a Python expression that will be evaluated"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(269,12),line_char(269,86))). -user:metta_file_buffer(3,113000215,metta_other,['@param',['@desc',"A string representing a Python expression that will be evaluated"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(269,4),line_char(269,87))). -user:metta_file_buffer(2,113000215,array,[['@param',['@desc',"A string representing a Python expression that will be evaluated"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(268,11),line_char(270,3))). -user:metta_file_buffer(1,113000215,metta_other,['@params',[['@param',['@desc',"A string representing a Python expression that will be evaluated"]]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(268,2),line_char(270,4))). -user:metta_file_buffer(2,113000216,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(271,3),line_char(271,10))). -user:metta_file_buffer(3,113000217,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(271,12),line_char(271,17))). -user:metta_file_buffer(3,113000217,string,"The result of evaluating the Python expression as a PyObject",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(271,18),line_char(271,80))). -user:metta_file_buffer(2,113000217,metta_other,['@desc',"The result of evaluating the Python expression as a PyObject"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(271,11),line_char(271,81))). -user:metta_file_buffer(1,113000217,metta_other,['@return',['@desc',"The result of evaluating the Python expression as a PyObject"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(271,2),line_char(271,82))). -user:metta_file_buffer(0,113000217,decl(doc),['@doc','py-eval',['@desc',"Evaluates a Python expression from a string and returns the result as a PyObject."],['@params',[['@param',['@desc',"A string representing a Python expression that will be evaluated"]]]],['@return',['@desc',"The result of evaluating the Python expression as a PyObject"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(266,0),line_char(272,1))). -user:metta_file_buffer(1,114000218,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(273,1),line_char(273,2))). -user:metta_file_buffer(1,114000218,constant,'py-eval',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(273,3),line_char(273,10))). -user:metta_file_buffer(2,114000219,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(273,12),line_char(273,14))). -user:metta_file_buffer(2,114000219,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(273,15),line_char(273,21))). -user:metta_file_buffer(2,114000219,constant,'PyObject',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(273,22),line_char(273,30))). -user:metta_file_buffer(1,114000219,metta_other,[->,'String','PyObject'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(273,11),line_char(273,31))). -user:metta_file_buffer(0,114000219,decl(ftype),[:,'py-eval',[->,'String','PyObject']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(273,0),line_char(273,32))). -user:metta_file_buffer(1,115000220,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(275,1),line_char(275,3))). -user:metta_file_buffer(1,115000220,constant,'py-exec!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(275,4),line_char(275,12))). -user:metta_file_buffer(1,115000220,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(275,13),line_char(275,21))). -user:metta_file_buffer(0,115000220,decl(impl),[iz,'py-exec!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(275,0),line_char(275,22))). -user:metta_file_buffer(1,116000221,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(276,1),line_char(276,5))). -user:metta_file_buffer(1,116000221,constant,'py-exec!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(276,6),line_char(276,14))). -user:metta_file_buffer(2,116000222,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(277,3),line_char(277,8))). -user:metta_file_buffer(2,116000222,string,"Executes some Python sourcecode from a string !(py-exec! \"import torch\") -> True. !(py-exec! \"import torche\") -> False. ",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(277,9),line_char(277,136))). -user:metta_file_buffer(1,116000222,metta_other,['@desc',"Executes some Python sourcecode from a string !(py-exec! \"import torch\") -> True. !(py-exec! \"import torche\") -> False. "],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(277,2),line_char(277,137))). -user:metta_file_buffer(2,116000223,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(278,3),line_char(278,10))). -user:metta_file_buffer(4,116000225,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(279,5),line_char(279,11))). -user:metta_file_buffer(5,116000226,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(279,13),line_char(279,18))). -user:metta_file_buffer(5,116000226,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(279,19),line_char(279,25))). -user:metta_file_buffer(4,116000226,metta_other,['@type','String'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(279,12),line_char(279,26))). -user:metta_file_buffer(5,116000227,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(279,28),line_char(279,33))). -user:metta_file_buffer(5,116000227,string,"A string representing a Python sourcecode that will be executed",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(279,34),line_char(279,99))). -user:metta_file_buffer(4,116000227,metta_other,['@desc',"A string representing a Python sourcecode that will be executed"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(279,27),line_char(279,100))). -user:metta_file_buffer(3,116000227,metta_other,['@param',['@type','String'],['@desc',"A string representing a Python sourcecode that will be executed"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(279,4),line_char(279,101))). -user:metta_file_buffer(2,116000227,array,[['@param',['@type','String'],['@desc',"A string representing a Python sourcecode that will be executed"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(278,11),line_char(280,3))). -user:metta_file_buffer(1,116000227,metta_other,['@params',[['@param',['@type','String'],['@desc',"A string representing a Python sourcecode that will be executed"]]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(278,2),line_char(280,4))). -user:metta_file_buffer(2,116000228,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(281,3),line_char(281,10))). -user:metta_file_buffer(3,116000229,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(281,12),line_char(281,17))). -user:metta_file_buffer(3,116000229,string,"The True|False results of executing the Python expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(281,18),line_char(281,77))). -user:metta_file_buffer(2,116000229,metta_other,['@desc',"The True|False results of executing the Python expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(281,11),line_char(281,78))). -user:metta_file_buffer(1,116000229,metta_other,['@return',['@desc',"The True|False results of executing the Python expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(281,2),line_char(281,79))). -user:metta_file_buffer(0,116000229,decl(doc),['@doc','py-exec!',['@desc',"Executes some Python sourcecode from a string !(py-exec! \"import torch\") -> True. !(py-exec! \"import torche\") -> False. "],['@params',[['@param',['@type','String'],['@desc',"A string representing a Python sourcecode that will be executed"]]]],['@return',['@desc',"The True|False results of executing the Python expression"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(276,0),line_char(282,1))). -user:metta_file_buffer(1,117000230,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(283,1),line_char(283,2))). -user:metta_file_buffer(1,117000230,constant,'py-exec!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(283,3),line_char(283,11))). -user:metta_file_buffer(2,117000231,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(283,13),line_char(283,15))). -user:metta_file_buffer(2,117000231,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(283,16),line_char(283,22))). -user:metta_file_buffer(2,117000231,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(283,23),line_char(283,27))). -user:metta_file_buffer(1,117000231,metta_other,[->,'String','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(283,12),line_char(283,28))). -user:metta_file_buffer(0,117000231,decl(ftype),[:,'py-exec!',[->,'String','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(283,0),line_char(283,29))). -user:metta_file_buffer(1,118000232,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(285,1),line_char(285,3))). -user:metta_file_buffer(1,118000232,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(285,4),line_char(285,5))). -user:metta_file_buffer(1,118000232,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(285,6),line_char(285,11))). -user:metta_file_buffer(0,118000232,decl(impl),[iz,=,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(285,0),line_char(285,12))). -user:metta_file_buffer(1,119000233,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(286,1),line_char(286,5))). -user:metta_file_buffer(1,119000233,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(286,6),line_char(286,7))). -user:metta_file_buffer(2,119000234,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(287,3),line_char(287,8))). -user:metta_file_buffer(2,119000234,string,"A symbol used to define reduction rules for expressions.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(287,9),line_char(287,67))). -user:metta_file_buffer(1,119000234,metta_other,['@desc',"A symbol used to define reduction rules for expressions."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(287,2),line_char(287,68))). -user:metta_file_buffer(2,119000235,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(288,3),line_char(288,10))). -user:metta_file_buffer(4,119000237,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(289,5),line_char(289,11))). -user:metta_file_buffer(4,119000237,string,"Pattern to be matched against expression to be reduced",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(289,12),line_char(289,68))). -user:metta_file_buffer(3,119000237,metta_other,['@param',"Pattern to be matched against expression to be reduced"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(289,4),line_char(289,69))). -user:metta_file_buffer(4,119000238,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(290,5),line_char(290,11))). -user:metta_file_buffer(4,119000238,string,"Result of reduction or transformation of the first pattern",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(290,12),line_char(290,72))). -user:metta_file_buffer(3,119000238,metta_other,['@param',"Result of reduction or transformation of the first pattern"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(290,4),line_char(290,73))). -user:metta_file_buffer(2,119000238,array,[['@param',"Pattern to be matched against expression to be reduced"],['@param',"Result of reduction or transformation of the first pattern"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(288,11),line_char(290,74))). -user:metta_file_buffer(1,119000238,metta_other,['@params',[['@param',"Pattern to be matched against expression to be reduced"],['@param',"Result of reduction or transformation of the first pattern"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(288,2),line_char(290,75))). -user:metta_file_buffer(2,119000239,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(291,3),line_char(291,10))). -user:metta_file_buffer(2,119000239,string,"Not reduced itself unless custom equalities over equalities are added",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(291,11),line_char(291,82))). -user:metta_file_buffer(1,119000239,metta_other,['@return',"Not reduced itself unless custom equalities over equalities are added"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(291,2),line_char(291,83))). -user:metta_file_buffer(0,119000239,decl(doc),['@doc',=,['@desc',"A symbol used to define reduction rules for expressions."],['@params',[['@param',"Pattern to be matched against expression to be reduced"],['@param',"Result of reduction or transformation of the first pattern"]]],['@return',"Not reduced itself unless custom equalities over equalities are added"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(286,0),line_char(291,85))). -user:metta_file_buffer(1,120000240,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(292,1),line_char(292,2))). -user:metta_file_buffer(1,120000240,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(292,3),line_char(292,4))). -user:metta_file_buffer(2,120000241,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(292,6),line_char(292,8))). -user:metta_file_buffer(2,120000241,variable,_52874,['_t'=_52874],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(292,9),line_char(292,11))). -user:metta_file_buffer(2,120000241,variable,_54110,['_t'=_54110],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(292,12),line_char(292,14))). -user:metta_file_buffer(2,120000241,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(292,15),line_char(292,19))). -user:metta_file_buffer(1,120000241,indexed(metta_other,[->,_55552,_55552,'Atom']),[->,_55630,_55630,'Atom'],['_t'=_55630],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(292,5),line_char(292,20))). -user:metta_file_buffer(0,120000241,indexed(decl(ftype),[:,=,[->,_56188,_56188,'Atom']]),[:,=,[->,_56284,_56284,'Atom']],['_t'=_56284],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(292,0),line_char(292,21))). -user:metta_file_buffer(1,121000242,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(293,1),line_char(293,2))). -user:metta_file_buffer(1,121000242,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(293,3),line_char(293,4))). -user:metta_file_buffer(2,121000243,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(293,6),line_char(293,8))). -user:metta_file_buffer(2,121000243,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(293,9),line_char(293,13))). -user:metta_file_buffer(2,121000243,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(293,14),line_char(293,18))). -user:metta_file_buffer(2,121000243,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(293,19),line_char(293,23))). -user:metta_file_buffer(1,121000243,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(293,5),line_char(293,24))). -user:metta_file_buffer(0,121000243,decl(ftype),[:,=,[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(293,0),line_char(293,25))). -user:metta_file_buffer(1,122000244,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(295,1),line_char(295,3))). -user:metta_file_buffer(1,122000244,constant,'ErrorType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(295,4),line_char(295,13))). -user:metta_file_buffer(1,122000244,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(295,14),line_char(295,19))). -user:metta_file_buffer(0,122000244,decl(impl),[iz,'ErrorType','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(295,0),line_char(295,20))). -user:metta_file_buffer(1,123000245,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(296,1),line_char(296,5))). -user:metta_file_buffer(1,123000245,constant,'ErrorType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(296,6),line_char(296,15))). -user:metta_file_buffer(2,123000246,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(296,17),line_char(296,22))). -user:metta_file_buffer(2,123000246,string,"Type of the atom which contains error",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(296,23),line_char(296,62))). -user:metta_file_buffer(1,123000246,metta_other,['@desc',"Type of the atom which contains error"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(296,16),line_char(296,63))). -user:metta_file_buffer(0,123000246,decl(doc),['@doc','ErrorType',['@desc',"Type of the atom which contains error"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(296,0),line_char(296,64))). -user:metta_file_buffer(1,124000247,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(297,1),line_char(297,2))). -user:metta_file_buffer(1,124000247,constant,'ErrorType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(297,3),line_char(297,12))). -user:metta_file_buffer(1,124000247,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(297,13),line_char(297,17))). -user:metta_file_buffer(0,124000247,decl(ftype),[:,'ErrorType','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(297,0),line_char(297,18))). -user:metta_file_buffer(1,125000248,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(299,1),line_char(299,3))). -user:metta_file_buffer(1,125000248,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(299,4),line_char(299,9))). -user:metta_file_buffer(1,125000248,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(299,10),line_char(299,15))). -user:metta_file_buffer(0,125000248,decl(impl),[iz,'Error','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(299,0),line_char(299,16))). -user:metta_file_buffer(1,126000249,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(300,1),line_char(300,5))). -user:metta_file_buffer(1,126000249,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(300,6),line_char(300,11))). -user:metta_file_buffer(2,126000250,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(301,3),line_char(301,8))). -user:metta_file_buffer(2,126000250,string,"Error constructor",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(301,9),line_char(301,28))). -user:metta_file_buffer(1,126000250,metta_other,['@desc',"Error constructor"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(301,2),line_char(301,29))). -user:metta_file_buffer(2,126000251,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(302,3),line_char(302,10))). -user:metta_file_buffer(4,126000253,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(303,5),line_char(303,11))). -user:metta_file_buffer(4,126000253,string,"Atom which contains error",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(303,12),line_char(303,39))). -user:metta_file_buffer(3,126000253,metta_other,['@param',"Atom which contains error"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(303,4),line_char(303,40))). -user:metta_file_buffer(4,126000254,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(304,5),line_char(304,11))). -user:metta_file_buffer(4,126000254,string,"Error message, can be one of the reserved symbols: BadType, IncorrectNumberOfArguments",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(304,12),line_char(304,100))). -user:metta_file_buffer(3,126000254,metta_other,['@param',"Error message, can be one of the reserved symbols: BadType, IncorrectNumberOfArguments"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(304,4),line_char(304,101))). -user:metta_file_buffer(2,126000254,array,[['@param',"Atom which contains error"],['@param',"Error message, can be one of the reserved symbols: BadType, IncorrectNumberOfArguments"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(302,11),line_char(304,102))). -user:metta_file_buffer(1,126000254,metta_other,['@params',[['@param',"Atom which contains error"],['@param',"Error message, can be one of the reserved symbols: BadType, IncorrectNumberOfArguments"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(302,2),line_char(304,103))). -user:metta_file_buffer(2,126000255,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(305,3),line_char(305,10))). -user:metta_file_buffer(2,126000255,string,"Instance of the error atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(305,11),line_char(305,39))). -user:metta_file_buffer(1,126000255,metta_other,['@return',"Instance of the error atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(305,2),line_char(305,40))). -user:metta_file_buffer(0,126000255,decl(doc),['@doc','Error',['@desc',"Error constructor"],['@params',[['@param',"Atom which contains error"],['@param',"Error message, can be one of the reserved symbols: BadType, IncorrectNumberOfArguments"]]],['@return',"Instance of the error atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(300,0),line_char(305,41))). -user:metta_file_buffer(1,127000256,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(306,1),line_char(306,2))). -user:metta_file_buffer(1,127000256,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(306,3),line_char(306,8))). -user:metta_file_buffer(2,127000257,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(306,10),line_char(306,12))). -user:metta_file_buffer(2,127000257,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(306,13),line_char(306,17))). -user:metta_file_buffer(2,127000257,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(306,18),line_char(306,22))). -user:metta_file_buffer(2,127000257,constant,'ErrorType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(306,23),line_char(306,32))). -user:metta_file_buffer(1,127000257,metta_other,[->,'Atom','Atom','ErrorType'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(306,9),line_char(306,33))). -user:metta_file_buffer(0,127000257,decl(ftype),[:,'Error',[->,'Atom','Atom','ErrorType']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(306,0),line_char(306,34))). -user:metta_file_buffer(1,128000258,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(308,1),line_char(308,3))). -user:metta_file_buffer(1,128000258,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(308,4),line_char(308,10))). -user:metta_file_buffer(1,128000258,constant,'MinimalMeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(308,11),line_char(308,23))). -user:metta_file_buffer(0,128000258,decl(impl),[iz,return,'MinimalMeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(308,0),line_char(308,24))). -user:metta_file_buffer(1,129000259,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(309,1),line_char(309,5))). -user:metta_file_buffer(1,129000259,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(309,6),line_char(309,12))). -user:metta_file_buffer(2,129000260,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(310,3),line_char(310,8))). -user:metta_file_buffer(2,129000260,string,"Returns value from the (function ...) expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(310,9),line_char(310,59))). -user:metta_file_buffer(1,129000260,metta_other,['@desc',"Returns value from the (function ...) expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(310,2),line_char(310,60))). -user:metta_file_buffer(2,129000261,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(311,3),line_char(311,10))). -user:metta_file_buffer(4,129000263,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(312,5),line_char(312,11))). -user:metta_file_buffer(4,129000263,string,"Value to be returned",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(312,12),line_char(312,34))). -user:metta_file_buffer(3,129000263,metta_other,['@param',"Value to be returned"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(312,4),line_char(312,35))). -user:metta_file_buffer(2,129000263,array,[['@param',"Value to be returned"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(311,11),line_char(312,36))). -user:metta_file_buffer(1,129000263,metta_other,['@params',[['@param',"Value to be returned"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(311,2),line_char(312,37))). -user:metta_file_buffer(2,129000264,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(313,3),line_char(313,10))). -user:metta_file_buffer(2,129000264,string,"Passed argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(313,11),line_char(313,28))). -user:metta_file_buffer(1,129000264,metta_other,['@return',"Passed argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(313,2),line_char(313,29))). -user:metta_file_buffer(0,129000264,decl(doc),['@doc',return,['@desc',"Returns value from the (function ...) expression"],['@params',[['@param',"Value to be returned"]]],['@return',"Passed argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(309,0),line_char(313,30))). -user:metta_file_buffer(1,130000265,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(314,1),line_char(314,2))). -user:metta_file_buffer(1,130000265,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(314,3),line_char(314,9))). -user:metta_file_buffer(2,130000266,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(314,11),line_char(314,13))). -user:metta_file_buffer(2,130000266,variable,_52924,['_t'=_52924],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(314,14),line_char(314,16))). -user:metta_file_buffer(2,130000266,variable,_54168,['_t'=_54168],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(314,17),line_char(314,19))). -user:metta_file_buffer(1,130000266,indexed(metta_other,[->,_55008,_55008]),[->,_55078,_55078],['_t'=_55078],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(314,10),line_char(314,20))). -user:metta_file_buffer(0,130000266,indexed(decl(ftype),[:,return,[->,_55636,_55636]]),[:,return,[->,_55724,_55724]],['_t'=_55724],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(314,0),line_char(314,21))). -user:metta_file_buffer(1,131000267,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(316,1),line_char(316,3))). -user:metta_file_buffer(1,131000267,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(316,4),line_char(316,12))). -user:metta_file_buffer(1,131000267,constant,'MinimalMeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(316,13),line_char(316,25))). -user:metta_file_buffer(0,131000267,decl(impl),[iz,function,'MinimalMeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(316,0),line_char(316,26))). -user:metta_file_buffer(1,132000268,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(317,1),line_char(317,5))). -user:metta_file_buffer(1,132000268,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(317,6),line_char(317,14))). -user:metta_file_buffer(2,132000269,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(318,3),line_char(318,8))). -user:metta_file_buffer(2,132000269,string,"Evaluates the argument until it becomes (return ). Then (function (return )) is reduced to the .",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(318,9),line_char(318,131))). -user:metta_file_buffer(1,132000269,metta_other,['@desc',"Evaluates the argument until it becomes (return ). Then (function (return )) is reduced to the ."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(318,2),line_char(318,132))). -user:metta_file_buffer(2,132000270,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(319,3),line_char(319,10))). -user:metta_file_buffer(4,132000272,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(320,5),line_char(320,11))). -user:metta_file_buffer(4,132000272,string,"Atom to be evaluated",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(320,12),line_char(320,34))). -user:metta_file_buffer(3,132000272,metta_other,['@param',"Atom to be evaluated"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(320,4),line_char(320,35))). -user:metta_file_buffer(2,132000272,array,[['@param',"Atom to be evaluated"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(319,11),line_char(320,36))). -user:metta_file_buffer(1,132000272,metta_other,['@params',[['@param',"Atom to be evaluated"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(319,2),line_char(320,37))). -user:metta_file_buffer(2,132000273,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(321,3),line_char(321,10))). -user:metta_file_buffer(2,132000273,string,"Result of atom's evaluation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(321,11),line_char(321,40))). -user:metta_file_buffer(1,132000273,metta_other,['@return',"Result of atom's evaluation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(321,2),line_char(321,41))). -user:metta_file_buffer(0,132000273,decl(doc),['@doc',function,['@desc',"Evaluates the argument until it becomes (return ). Then (function (return )) is reduced to the ."],['@params',[['@param',"Atom to be evaluated"]]],['@return',"Result of atom's evaluation"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(317,0),line_char(321,42))). -user:metta_file_buffer(1,133000274,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(322,1),line_char(322,2))). -user:metta_file_buffer(1,133000274,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(322,3),line_char(322,11))). -user:metta_file_buffer(2,133000275,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(322,13),line_char(322,15))). -user:metta_file_buffer(2,133000275,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(322,16),line_char(322,20))). -user:metta_file_buffer(2,133000275,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(322,21),line_char(322,25))). -user:metta_file_buffer(1,133000275,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(322,12),line_char(322,26))). -user:metta_file_buffer(0,133000275,decl(ftype),[:,function,[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(322,0),line_char(322,27))). -user:metta_file_buffer(1,134000276,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(324,1),line_char(324,3))). -user:metta_file_buffer(1,134000276,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(324,4),line_char(324,8))). -user:metta_file_buffer(1,134000276,constant,'MinimalMeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(324,9),line_char(324,21))). -user:metta_file_buffer(0,134000276,decl(impl),[iz,eval,'MinimalMeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(324,0),line_char(324,22))). -user:metta_file_buffer(1,135000277,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(325,1),line_char(325,5))). -user:metta_file_buffer(1,135000277,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(325,6),line_char(325,10))). -user:metta_file_buffer(2,135000278,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(326,3),line_char(326,8))). -user:metta_file_buffer(2,135000278,string,"Evaluates input Atom, performs one step of the evaluation. Empty results (Empty, ()) are removed from the result set. If no results are produced for a non-grounded function, eval returns NotReducible.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(326,9),line_char(326,211))). -user:metta_file_buffer(1,135000278,metta_other,['@desc',"Evaluates input Atom, performs one step of the evaluation. Empty results (Empty, ()) are removed from the result set. If no results are produced for a non-grounded function, eval returns NotReducible."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(326,2),line_char(326,212))). -user:metta_file_buffer(2,135000279,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(327,3),line_char(327,10))). -user:metta_file_buffer(4,135000281,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(328,5),line_char(328,11))). -user:metta_file_buffer(4,135000281,string,"Atom to be evaluated, can be reduced via equality expression (= ...) or by calling a grounded function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(328,12),line_char(328,116))). -user:metta_file_buffer(3,135000281,metta_other,['@param',"Atom to be evaluated, can be reduced via equality expression (= ...) or by calling a grounded function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(328,4),line_char(328,117))). -user:metta_file_buffer(2,135000281,array,[['@param',"Atom to be evaluated, can be reduced via equality expression (= ...) or by calling a grounded function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(327,11),line_char(328,118))). -user:metta_file_buffer(1,135000281,metta_other,['@params',[['@param',"Atom to be evaluated, can be reduced via equality expression (= ...) or by calling a grounded function"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(327,2),line_char(328,119))). -user:metta_file_buffer(2,135000282,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(329,3),line_char(329,10))). -user:metta_file_buffer(2,135000282,string,"Result of evaluation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(329,11),line_char(329,33))). -user:metta_file_buffer(1,135000282,metta_other,['@return',"Result of evaluation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(329,2),line_char(329,34))). -user:metta_file_buffer(0,135000282,decl(doc),['@doc',eval,['@desc',"Evaluates input Atom, performs one step of the evaluation. Empty results (Empty, ()) are removed from the result set. If no results are produced for a non-grounded function, eval returns NotReducible."],['@params',[['@param',"Atom to be evaluated, can be reduced via equality expression (= ...) or by calling a grounded function"]]],['@return',"Result of evaluation"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(325,0),line_char(329,35))). -user:metta_file_buffer(1,136000283,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(330,1),line_char(330,2))). -user:metta_file_buffer(1,136000283,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(330,3),line_char(330,7))). -user:metta_file_buffer(2,136000284,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(330,9),line_char(330,11))). -user:metta_file_buffer(2,136000284,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(330,12),line_char(330,16))). -user:metta_file_buffer(2,136000284,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(330,17),line_char(330,21))). -user:metta_file_buffer(1,136000284,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(330,8),line_char(330,22))). -user:metta_file_buffer(0,136000284,decl(ftype),[:,eval,[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(330,0),line_char(330,23))). -user:metta_file_buffer(1,137000285,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(332,1),line_char(332,3))). -user:metta_file_buffer(1,137000285,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(332,4),line_char(332,8))). -user:metta_file_buffer(1,137000285,constant,'MinimalMeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(332,9),line_char(332,21))). -user:metta_file_buffer(0,137000285,decl(impl),[iz,eval,'MinimalMeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(332,0),line_char(332,22))). -user:metta_file_buffer(1,138000286,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(333,1),line_char(333,5))). -user:metta_file_buffer(1,138000286,constant,evalc,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(333,6),line_char(333,11))). -user:metta_file_buffer(2,138000287,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(334,3),line_char(334,8))). -user:metta_file_buffer(2,138000287,string,"Evaluates input atom, makes one step of the evaluation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(334,9),line_char(334,65))). -user:metta_file_buffer(1,138000287,metta_other,['@desc',"Evaluates input atom, makes one step of the evaluation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(334,2),line_char(334,66))). -user:metta_file_buffer(2,138000288,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(335,3),line_char(335,10))). -user:metta_file_buffer(4,138000290,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(336,5),line_char(336,11))). -user:metta_file_buffer(4,138000290,string,"Atom to be evaluated, can be reduced via equality expression (= ...) or by calling a grounded function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(336,12),line_char(336,116))). -user:metta_file_buffer(3,138000290,metta_other,['@param',"Atom to be evaluated, can be reduced via equality expression (= ...) or by calling a grounded function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(336,4),line_char(336,117))). -user:metta_file_buffer(4,138000291,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(337,5),line_char(337,11))). -user:metta_file_buffer(4,138000291,string,"Space to evaluate atom in its context",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(337,12),line_char(337,51))). -user:metta_file_buffer(3,138000291,metta_other,['@param',"Space to evaluate atom in its context"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(337,4),line_char(337,52))). -user:metta_file_buffer(2,138000291,array,[['@param',"Atom to be evaluated, can be reduced via equality expression (= ...) or by calling a grounded function"],['@param',"Space to evaluate atom in its context"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(335,11),line_char(337,53))). -user:metta_file_buffer(1,138000291,metta_other,['@params',[['@param',"Atom to be evaluated, can be reduced via equality expression (= ...) or by calling a grounded function"],['@param',"Space to evaluate atom in its context"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(335,2),line_char(337,54))). -user:metta_file_buffer(2,138000292,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(338,3),line_char(338,10))). -user:metta_file_buffer(2,138000292,string,"Result of evaluation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(338,11),line_char(338,33))). -user:metta_file_buffer(1,138000292,metta_other,['@return',"Result of evaluation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(338,2),line_char(338,34))). -user:metta_file_buffer(0,138000292,decl(doc),['@doc',evalc,['@desc',"Evaluates input atom, makes one step of the evaluation"],['@params',[['@param',"Atom to be evaluated, can be reduced via equality expression (= ...) or by calling a grounded function"],['@param',"Space to evaluate atom in its context"]]],['@return',"Result of evaluation"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(333,0),line_char(338,35))). -user:metta_file_buffer(1,139000293,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(339,1),line_char(339,2))). -user:metta_file_buffer(1,139000293,constant,evalc,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(339,3),line_char(339,8))). -user:metta_file_buffer(2,139000294,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(339,10),line_char(339,12))). -user:metta_file_buffer(2,139000294,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(339,13),line_char(339,17))). -user:metta_file_buffer(2,139000294,constant,'Grounded',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(339,18),line_char(339,26))). -user:metta_file_buffer(2,139000294,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(339,27),line_char(339,31))). -user:metta_file_buffer(1,139000294,metta_other,[->,'Atom','Grounded','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(339,9),line_char(339,32))). -user:metta_file_buffer(0,139000294,decl(ftype),[:,evalc,[->,'Atom','Grounded','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(339,0),line_char(339,33))). -user:metta_file_buffer(1,140000295,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(341,1),line_char(341,3))). -user:metta_file_buffer(1,140000295,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(341,4),line_char(341,9))). -user:metta_file_buffer(1,140000295,constant,'MinimalMeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(341,10),line_char(341,22))). -user:metta_file_buffer(0,140000295,decl(impl),[iz,chain,'MinimalMeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(341,0),line_char(341,23))). -user:metta_file_buffer(1,141000296,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(342,1),line_char(342,5))). -user:metta_file_buffer(1,141000296,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(342,6),line_char(342,11))). -user:metta_file_buffer(2,141000297,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(343,3),line_char(343,8))). -user:metta_file_buffer(2,141000297,string,"Evaluates first argument Atom, binds it to the Variable (second argument) and then evaluates third argument Template with Variable substituted in. When evaluation of the first Atom brings more than a single result, chain returns one instance of the Template expression for each result. The first argument Atom is only evaluated if it is part of the Minimal MeTTa specification; evaluation of non-Minimal MeTTa atoms can be controlled by wrapping in a call to eval (for one evaluation step) or metta (for full evaluation).",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(343,9),line_char(343,532))). -user:metta_file_buffer(1,141000297,metta_other,['@desc',"Evaluates first argument Atom, binds it to the Variable (second argument) and then evaluates third argument Template with Variable substituted in. When evaluation of the first Atom brings more than a single result, chain returns one instance of the Template expression for each result. The first argument Atom is only evaluated if it is part of the Minimal MeTTa specification; evaluation of non-Minimal MeTTa atoms can be controlled by wrapping in a call to eval (for one evaluation step) or metta (for full evaluation)."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(343,2),line_char(343,533))). -user:metta_file_buffer(2,141000298,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(344,3),line_char(344,10))). -user:metta_file_buffer(4,141000300,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(345,5),line_char(345,11))). -user:metta_file_buffer(4,141000300,string,"Atom to be evaluated",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(345,12),line_char(345,34))). -user:metta_file_buffer(3,141000300,metta_other,['@param',"Atom to be evaluated"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(345,4),line_char(345,35))). -user:metta_file_buffer(4,141000301,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(346,5),line_char(346,11))). -user:metta_file_buffer(4,141000301,string,"Variable",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(346,12),line_char(346,22))). -user:metta_file_buffer(3,141000301,metta_other,['@param',"Variable"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(346,4),line_char(346,23))). -user:metta_file_buffer(4,141000302,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(347,5),line_char(347,11))). -user:metta_file_buffer(4,141000302,string,"Template which will be evaluated at the end with Variable substituted",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(347,12),line_char(347,83))). -user:metta_file_buffer(3,141000302,metta_other,['@param',"Template which will be evaluated at the end with Variable substituted"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(347,4),line_char(347,84))). -user:metta_file_buffer(2,141000302,array,[['@param',"Atom to be evaluated"],['@param',"Variable"],['@param',"Template which will be evaluated at the end with Variable substituted"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(344,11),line_char(347,85))). -user:metta_file_buffer(1,141000302,metta_other,['@params',[['@param',"Atom to be evaluated"],['@param',"Variable"],['@param',"Template which will be evaluated at the end with Variable substituted"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(344,2),line_char(347,86))). -user:metta_file_buffer(2,141000303,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(348,3),line_char(348,10))). -user:metta_file_buffer(2,141000303,string,"Result of evaluating third input argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(348,11),line_char(348,54))). -user:metta_file_buffer(1,141000303,metta_other,['@return',"Result of evaluating third input argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(348,2),line_char(348,55))). -user:metta_file_buffer(0,141000303,decl(doc),['@doc',chain,['@desc',"Evaluates first argument Atom, binds it to the Variable (second argument) and then evaluates third argument Template with Variable substituted in. When evaluation of the first Atom brings more than a single result, chain returns one instance of the Template expression for each result. The first argument Atom is only evaluated if it is part of the Minimal MeTTa specification; evaluation of non-Minimal MeTTa atoms can be controlled by wrapping in a call to eval (for one evaluation step) or metta (for full evaluation)."],['@params',[['@param',"Atom to be evaluated"],['@param',"Variable"],['@param',"Template which will be evaluated at the end with Variable substituted"]]],['@return',"Result of evaluating third input argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(342,0),line_char(348,56))). -user:metta_file_buffer(1,142000304,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(349,1),line_char(349,2))). -user:metta_file_buffer(1,142000304,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(349,3),line_char(349,8))). -user:metta_file_buffer(2,142000305,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(349,10),line_char(349,12))). -user:metta_file_buffer(2,142000305,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(349,13),line_char(349,17))). -user:metta_file_buffer(2,142000305,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(349,18),line_char(349,26))). -user:metta_file_buffer(2,142000305,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(349,27),line_char(349,31))). -user:metta_file_buffer(2,142000305,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(349,32),line_char(349,36))). -user:metta_file_buffer(1,142000305,metta_other,[->,'Atom','Variable','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(349,9),line_char(349,37))). -user:metta_file_buffer(0,142000305,decl(ftype),[:,chain,[->,'Atom','Variable','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(349,0),line_char(349,38))). -user:metta_file_buffer(1,143000306,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(351,1),line_char(351,3))). -user:metta_file_buffer(1,143000306,constant,unify,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(351,4),line_char(351,9))). -user:metta_file_buffer(1,143000306,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(351,10),line_char(351,15))). -user:metta_file_buffer(0,143000306,decl(impl),[iz,unify,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(351,0),line_char(351,16))). -user:metta_file_buffer(1,144000307,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(352,1),line_char(352,5))). -user:metta_file_buffer(1,144000307,constant,unify,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(352,6),line_char(352,11))). -user:metta_file_buffer(2,144000308,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(353,3),line_char(353,8))). -user:metta_file_buffer(2,144000308,string,"Like Match but allows any sort of container for the first argument. (Match only allows MeTTa spaces.)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(353,9),line_char(353,112))). -user:metta_file_buffer(1,144000308,metta_other,['@desc',"Like Match but allows any sort of container for the first argument. (Match only allows MeTTa spaces.)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(353,2),line_char(353,113))). -user:metta_file_buffer(2,144000309,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(354,3),line_char(354,10))). -user:metta_file_buffer(4,144000311,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(355,9),line_char(355,15))). -user:metta_file_buffer(4,144000311,string,"The collection or space to match",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(355,16),line_char(355,50))). -user:metta_file_buffer(3,144000311,metta_other,['@param',"The collection or space to match"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(355,8),line_char(355,51))). -user:metta_file_buffer(4,144000312,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(356,9),line_char(356,15))). -user:metta_file_buffer(4,144000312,string,"Second atom to unify with",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(356,16),line_char(356,43))). -user:metta_file_buffer(3,144000312,metta_other,['@param',"Second atom to unify with"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(356,8),line_char(356,44))). -user:metta_file_buffer(4,144000313,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(357,9),line_char(357,15))). -user:metta_file_buffer(4,144000313,string,"Result if two atoms unified successfully",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(357,16),line_char(357,58))). -user:metta_file_buffer(3,144000313,metta_other,['@param',"Result if two atoms unified successfully"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(357,8),line_char(357,59))). -user:metta_file_buffer(4,144000314,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(358,9),line_char(358,15))). -user:metta_file_buffer(4,144000314,string,"Result otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(358,16),line_char(358,34))). -user:metta_file_buffer(3,144000314,metta_other,['@param',"Result otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(358,8),line_char(358,35))). -user:metta_file_buffer(2,144000314,array,[['@param',"The collection or space to match"],['@param',"Second atom to unify with"],['@param',"Result if two atoms unified successfully"],['@param',"Result otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(354,11),line_char(358,36))). -user:metta_file_buffer(1,144000314,metta_other,['@params',[['@param',"The collection or space to match"],['@param',"Second atom to unify with"],['@param',"Result if two atoms unified successfully"],['@param',"Result otherwise"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(354,2),line_char(358,37))). -user:metta_file_buffer(2,144000315,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(359,3),line_char(359,10))). -user:metta_file_buffer(2,144000315,string,"Third argument when found or fourth one otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(359,11),line_char(359,62))). -user:metta_file_buffer(1,144000315,metta_other,['@return',"Third argument when found or fourth one otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(359,2),line_char(359,63))). -user:metta_file_buffer(0,144000315,decl(doc),['@doc',unify,['@desc',"Like Match but allows any sort of container for the first argument. (Match only allows MeTTa spaces.)"],['@params',[['@param',"The collection or space to match"],['@param',"Second atom to unify with"],['@param',"Result if two atoms unified successfully"],['@param',"Result otherwise"]]],['@return',"Third argument when found or fourth one otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(352,0),line_char(359,64))). -user:metta_file_buffer(1,145000316,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(360,1),line_char(360,2))). -user:metta_file_buffer(1,145000316,constant,unify,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(360,3),line_char(360,8))). -user:metta_file_buffer(2,145000317,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(360,10),line_char(360,12))). -user:metta_file_buffer(2,145000317,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(360,13),line_char(360,17))). -user:metta_file_buffer(2,145000317,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(360,18),line_char(360,22))). -user:metta_file_buffer(2,145000317,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(360,23),line_char(360,27))). -user:metta_file_buffer(2,145000317,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(360,28),line_char(360,32))). -user:metta_file_buffer(2,145000317,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(360,33),line_char(360,37))). -user:metta_file_buffer(1,145000317,metta_other,[->,'Atom','Atom','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(360,9),line_char(360,38))). -user:metta_file_buffer(0,145000317,decl(ftype),[:,unify,[->,'Atom','Atom','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(360,0),line_char(360,39))). -user:metta_file_buffer(1,146000318,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(362,1),line_char(362,3))). -user:metta_file_buffer(1,146000318,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(362,4),line_char(362,12))). -user:metta_file_buffer(1,146000318,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(362,13),line_char(362,31))). -user:metta_file_buffer(0,146000318,decl(impl),[iz,'if-unify','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(362,0),line_char(362,32))). -user:metta_file_buffer(1,147000319,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(363,1),line_char(363,5))). -user:metta_file_buffer(1,147000319,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(363,6),line_char(363,14))). -user:metta_file_buffer(2,147000320,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(364,3),line_char(364,8))). -user:metta_file_buffer(2,147000320,string,"Matches two first terms and returns third argument if they are matched and fourth argument otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(364,9),line_char(364,111))). -user:metta_file_buffer(1,147000320,metta_other,['@desc',"Matches two first terms and returns third argument if they are matched and fourth argument otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(364,2),line_char(364,112))). -user:metta_file_buffer(2,147000321,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(365,3),line_char(365,10))). -user:metta_file_buffer(4,147000323,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(366,9),line_char(366,15))). -user:metta_file_buffer(4,147000323,string,"First term to unify with",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(366,16),line_char(366,42))). -user:metta_file_buffer(3,147000323,metta_other,['@param',"First term to unify with"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(366,8),line_char(366,43))). -user:metta_file_buffer(4,147000324,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(367,9),line_char(367,15))). -user:metta_file_buffer(4,147000324,string,"Second atom to unify with",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(367,16),line_char(367,43))). -user:metta_file_buffer(3,147000324,metta_other,['@param',"Second atom to unify with"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(367,8),line_char(367,44))). -user:metta_file_buffer(4,147000325,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(368,9),line_char(368,15))). -user:metta_file_buffer(4,147000325,string,"Result if two atoms unified successfully",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(368,16),line_char(368,58))). -user:metta_file_buffer(3,147000325,metta_other,['@param',"Result if two atoms unified successfully"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(368,8),line_char(368,59))). -user:metta_file_buffer(4,147000326,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(369,9),line_char(369,15))). -user:metta_file_buffer(4,147000326,string,"Result otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(369,16),line_char(369,34))). -user:metta_file_buffer(3,147000326,metta_other,['@param',"Result otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(369,8),line_char(369,35))). -user:metta_file_buffer(2,147000326,array,[['@param',"First term to unify with"],['@param',"Second atom to unify with"],['@param',"Result if two atoms unified successfully"],['@param',"Result otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(365,11),line_char(369,36))). -user:metta_file_buffer(1,147000326,metta_other,['@params',[['@param',"First term to unify with"],['@param',"Second atom to unify with"],['@param',"Result if two atoms unified successfully"],['@param',"Result otherwise"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(365,2),line_char(369,37))). -user:metta_file_buffer(2,147000327,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(370,3),line_char(370,10))). -user:metta_file_buffer(2,147000327,string,"Third argument when first two atoms are unifiable or fourth one otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(370,11),line_char(370,86))). -user:metta_file_buffer(1,147000327,metta_other,['@return',"Third argument when first two atoms are unifiable or fourth one otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(370,2),line_char(370,87))). -user:metta_file_buffer(0,147000327,decl(doc),['@doc','if-unify',['@desc',"Matches two first terms and returns third argument if they are matched and fourth argument otherwise"],['@params',[['@param',"First term to unify with"],['@param',"Second atom to unify with"],['@param',"Result if two atoms unified successfully"],['@param',"Result otherwise"]]],['@return',"Third argument when first two atoms are unifiable or fourth one otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(363,0),line_char(370,88))). -user:metta_file_buffer(1,148000328,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(371,1),line_char(371,2))). -user:metta_file_buffer(1,148000328,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(371,3),line_char(371,11))). -user:metta_file_buffer(2,148000329,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(371,13),line_char(371,15))). -user:metta_file_buffer(2,148000329,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(371,16),line_char(371,20))). -user:metta_file_buffer(2,148000329,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(371,21),line_char(371,25))). -user:metta_file_buffer(2,148000329,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(371,26),line_char(371,30))). -user:metta_file_buffer(2,148000329,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(371,31),line_char(371,35))). -user:metta_file_buffer(2,148000329,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(371,36),line_char(371,47))). -user:metta_file_buffer(1,148000329,metta_other,[->,'Atom','Atom','Atom','Atom','%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(371,12),line_char(371,48))). -user:metta_file_buffer(0,148000329,decl(ftype),[:,'if-unify',[->,'Atom','Atom','Atom','Atom','%Undefined%']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(371,0),line_char(371,49))). -user:metta_file_buffer(1,149000330,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(373,1),line_char(373,5))). -user:metta_file_buffer(2,149000331,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(373,7),line_char(373,15))). -user:metta_file_buffer(2,149000331,variable,_57254,['_a'=_57254],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(373,16),line_char(373,18))). -user:metta_file_buffer(2,149000331,variable,_58490,['_a'=_58490],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(373,19),line_char(373,21))). -user:metta_file_buffer(2,149000331,variable,_59774,['_then'=_59774],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(373,22),line_char(373,27))). -user:metta_file_buffer(2,149000331,variable,_61066,['_else'=_61066],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(373,28),line_char(373,33))). -user:metta_file_buffer(1,149000331,indexed(metta_other,['if-unify',_61918,_61918,_61958,_61980]),['if-unify',_62032,_62032,_62044,_62050],['_else'=_62050,'_then'=_62044,'_a'=_62032],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(373,6),line_char(373,34))). -user:metta_file_buffer(1,149000331,variable,_63054,['_then'=_63054],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(373,35),line_char(373,40))). -user:metta_file_buffer(0,149000331,indexed(decl(impl),['ALT=',['if-unify',_63910,_63910,_63950,_63972],_63950]),['ALT=',['if-unify',_64054,_64054,_64066,_64072],_64066],['_else'=_64072,'_then'=_64066,'_a'=_64054],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(373,0),line_char(373,41))). -user:metta_file_buffer(1,150000332,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(374,1),line_char(374,5))). -user:metta_file_buffer(2,150000333,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(374,7),line_char(374,15))). -user:metta_file_buffer(2,150000333,variable,_57738,['_a'=_57738],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(374,16),line_char(374,18))). -user:metta_file_buffer(2,150000333,variable,_58974,['_b'=_58974],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(374,19),line_char(374,21))). -user:metta_file_buffer(2,150000333,variable,_60258,['_then'=_60258],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(374,22),line_char(374,27))). -user:metta_file_buffer(2,150000333,variable,_61550,['_else'=_61550],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(374,28),line_char(374,33))). -user:metta_file_buffer(1,150000333,indexed(metta_other,['if-unify',_62402,_62424,_62446,_62468]),['if-unify',_62520,_62526,_62532,_62538],['_else'=_62538,'_then'=_62532,'_b'=_62526,'_a'=_62520],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(374,6),line_char(374,34))). -user:metta_file_buffer(2,150000334,constant,case,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(375,3),line_char(375,7))). -user:metta_file_buffer(3,150000335,constant,'if-unify-or-empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(375,9),line_char(375,26))). -user:metta_file_buffer(3,150000335,variable,_65152,['_a'=_65152],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(375,27),line_char(375,29))). -user:metta_file_buffer(3,150000335,variable,_66396,['_b'=_66396],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(375,30),line_char(375,32))). -user:metta_file_buffer(2,150000335,indexed(metta_other,['if-unify-or-empty',_67236,_67258]),['if-unify-or-empty',_67310,_67316],['_b'=_67316,'_a'=_67310],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(375,8),line_char(375,33))). -user:metta_file_buffer(4,150000337,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(375,36),line_char(375,41))). -user:metta_file_buffer(4,150000337,variable,_69182,['_else'=_69182],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(375,42),line_char(375,47))). -user:metta_file_buffer(3,150000337,indexed(metta_other,['Empty',_70016]),['Empty',_70068],['_else'=_70068],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(375,35),line_char(375,48))). -user:metta_file_buffer(2,150000337,indexed(array,[['Empty',_70592]]),[['Empty',_70650]],['_else'=_70650],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(375,34),line_char(375,49))). -user:metta_file_buffer(1,150000337,indexed(metta_other,[case,['if-unify-or-empty',_71200,_71222],[['Empty',_71268]]]),[case,['if-unify-or-empty',_71332,_71338],[['Empty',_71362]]],['_else'=_71362,'_b'=_71338,'_a'=_71332],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(375,2),line_char(375,50))). -user:metta_file_buffer(0,150000337,indexed(decl(impl),['ALT=',['if-unify',_71932,_71954,_71976,_71998],[case,['if-unify-or-empty',_71932,_71954],[['Empty',_71998]]]]),['ALT=',['if-unify',_72172,_72178,_72184,_72190],[case,['if-unify-or-empty',_72172,_72178],[['Empty',_72190]]]],['_else'=_72190,'_then'=_72184,'_b'=_72178,'_a'=_72172],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(374,0),line_char(375,52))). -user:metta_file_buffer(1,151000338,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(377,1),line_char(377,3))). -user:metta_file_buffer(1,151000338,constant,'if-unify-or-empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(377,4),line_char(377,21))). -user:metta_file_buffer(1,151000338,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(377,22),line_char(377,40))). -user:metta_file_buffer(0,151000338,decl(impl),[iz,'if-unify-or-empty','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(377,0),line_char(377,41))). -user:metta_file_buffer(1,152000339,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(378,1),line_char(378,5))). -user:metta_file_buffer(1,152000339,constant,'if-unify-or-empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(378,6),line_char(378,23))). -user:metta_file_buffer(2,152000340,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(379,3),line_char(379,8))). -user:metta_file_buffer(2,152000340,string,"Attempts to unify two atoms and returns a result. Returns Empty if they cannot be unified.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(379,9),line_char(379,101))). -user:metta_file_buffer(1,152000340,metta_other,['@desc',"Attempts to unify two atoms and returns a result. Returns Empty if they cannot be unified."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(379,2),line_char(379,102))). -user:metta_file_buffer(2,152000341,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(380,3),line_char(380,10))). -user:metta_file_buffer(4,152000343,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(381,5),line_char(381,11))). -user:metta_file_buffer(4,152000343,string,"First atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(381,12),line_char(381,24))). -user:metta_file_buffer(3,152000343,metta_other,['@param',"First atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(381,4),line_char(381,25))). -user:metta_file_buffer(4,152000344,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(382,5),line_char(382,11))). -user:metta_file_buffer(4,152000344,string,"Second atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(382,12),line_char(382,25))). -user:metta_file_buffer(3,152000344,metta_other,['@param',"Second atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(382,4),line_char(382,26))). -user:metta_file_buffer(2,152000344,array,[['@param',"First atom"],['@param',"Second atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(380,11),line_char(382,27))). -user:metta_file_buffer(1,152000344,metta_other,['@params',[['@param',"First atom"],['@param',"Second atom"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(380,2),line_char(382,28))). -user:metta_file_buffer(2,152000345,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(383,3),line_char(383,10))). -user:metta_file_buffer(2,152000345,string,"Unification result or Empty",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(383,11),line_char(383,40))). -user:metta_file_buffer(1,152000345,metta_other,['@return',"Unification result or Empty"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(383,2),line_char(383,41))). -user:metta_file_buffer(0,152000345,decl(doc),['@doc','if-unify-or-empty',['@desc',"Attempts to unify two atoms and returns a result. Returns Empty if they cannot be unified."],['@params',[['@param',"First atom"],['@param',"Second atom"]]],['@return',"Unification result or Empty"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(378,0),line_char(383,42))). -user:metta_file_buffer(1,153000346,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(384,1),line_char(384,2))). -user:metta_file_buffer(1,153000346,constant,'if-unify-or-empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(384,3),line_char(384,20))). -user:metta_file_buffer(2,153000347,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(384,22),line_char(384,24))). -user:metta_file_buffer(2,153000347,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(384,25),line_char(384,29))). -user:metta_file_buffer(2,153000347,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(384,30),line_char(384,34))). -user:metta_file_buffer(2,153000347,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(384,35),line_char(384,39))). -user:metta_file_buffer(1,153000347,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(384,21),line_char(384,40))). -user:metta_file_buffer(0,153000347,decl(ftype),[:,'if-unify-or-empty',[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(384,0),line_char(384,41))). -user:metta_file_buffer(1,154000348,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(385,1),line_char(385,2))). -user:metta_file_buffer(2,154000349,constant,'if-unify-or-empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(385,4),line_char(385,21))). -user:metta_file_buffer(2,154000349,variable,_58240,['_a'=_58240],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(385,22),line_char(385,24))). -user:metta_file_buffer(2,154000349,variable,_59484,['_a'=_59484],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(385,25),line_char(385,27))). -user:metta_file_buffer(1,154000349,indexed(metta_other,['if-unify-or-empty',_60324,_60324]),['if-unify-or-empty',_60394,_60394],['_a'=_60394],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(385,3),line_char(385,28))). -user:metta_file_buffer(1,154000349,constant,unified,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(385,29),line_char(385,36))). -user:metta_file_buffer(0,154000349,indexed(decl(impl),['if-unify-or-empty',_61638,_61638]),[=,['if-unify-or-empty',_61728,_61728],unified],['_a'=_61728],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(385,0),line_char(385,37))). -user:metta_file_buffer(1,155000350,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(386,1),line_char(386,2))). -user:metta_file_buffer(2,155000351,constant,'if-unify-or-empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(386,4),line_char(386,21))). -user:metta_file_buffer(2,155000351,variable,_58240,['_a'=_58240],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(386,22),line_char(386,24))). -user:metta_file_buffer(2,155000351,variable,_59484,['_b'=_59484],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(386,25),line_char(386,27))). -user:metta_file_buffer(1,155000351,indexed(metta_other,['if-unify-or-empty',_60324,_60346]),['if-unify-or-empty',_60398,_60404],['_b'=_60404,'_a'=_60398],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(386,3),line_char(386,28))). -user:metta_file_buffer(2,155000352,constant,empty,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(386,30),line_char(386,35))). -user:metta_file_buffer(1,155000352,metta_other,[empty],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(386,29),line_char(386,36))). -user:metta_file_buffer(0,155000352,indexed(decl(impl),['if-unify-or-empty',_62294,_62316]),[=,['if-unify-or-empty',_62396,_62402],[empty]],['_b'=_62402,'_a'=_62396],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(386,0),line_char(386,37))). -user:metta_file_buffer(1,156000353,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(388,1),line_char(388,3))). -user:metta_file_buffer(1,156000353,constant,'cons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(388,4),line_char(388,13))). -user:metta_file_buffer(1,156000353,constant,'MinimalMeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(388,14),line_char(388,26))). -user:metta_file_buffer(0,156000353,decl(impl),[iz,'cons-atom','MinimalMeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(388,0),line_char(388,27))). -user:metta_file_buffer(1,157000354,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(389,1),line_char(389,5))). -user:metta_file_buffer(1,157000354,constant,'cons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(389,6),line_char(389,15))). -user:metta_file_buffer(2,157000355,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(390,3),line_char(390,8))). -user:metta_file_buffer(2,157000355,string,"Constructs an expression using two arguments",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(390,9),line_char(390,55))). -user:metta_file_buffer(1,157000355,metta_other,['@desc',"Constructs an expression using two arguments"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(390,2),line_char(390,56))). -user:metta_file_buffer(2,157000356,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(391,3),line_char(391,10))). -user:metta_file_buffer(4,157000358,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(392,5),line_char(392,11))). -user:metta_file_buffer(4,157000358,string,"Head of an expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(392,12),line_char(392,35))). -user:metta_file_buffer(3,157000358,metta_other,['@param',"Head of an expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(392,4),line_char(392,36))). -user:metta_file_buffer(4,157000359,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(393,5),line_char(393,11))). -user:metta_file_buffer(4,157000359,string,"Tail of an expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(393,12),line_char(393,35))). -user:metta_file_buffer(3,157000359,metta_other,['@param',"Tail of an expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(393,4),line_char(393,36))). -user:metta_file_buffer(2,157000359,array,[['@param',"Head of an expression"],['@param',"Tail of an expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(391,11),line_char(393,37))). -user:metta_file_buffer(1,157000359,metta_other,['@params',[['@param',"Head of an expression"],['@param',"Tail of an expression"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(391,2),line_char(393,38))). -user:metta_file_buffer(2,157000360,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(394,3),line_char(394,10))). -user:metta_file_buffer(2,157000360,string,"New expression consisting of the two input arguments",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(394,11),line_char(394,65))). -user:metta_file_buffer(1,157000360,metta_other,['@return',"New expression consisting of the two input arguments"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(394,2),line_char(394,66))). -user:metta_file_buffer(0,157000360,decl(doc),['@doc','cons-atom',['@desc',"Constructs an expression using two arguments"],['@params',[['@param',"Head of an expression"],['@param',"Tail of an expression"]]],['@return',"New expression consisting of the two input arguments"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(389,0),line_char(394,67))). -user:metta_file_buffer(1,158000361,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(395,1),line_char(395,2))). -user:metta_file_buffer(1,158000361,constant,'cons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(395,3),line_char(395,12))). -user:metta_file_buffer(2,158000362,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(395,14),line_char(395,16))). -user:metta_file_buffer(2,158000362,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(395,17),line_char(395,21))). -user:metta_file_buffer(2,158000362,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(395,22),line_char(395,32))). -user:metta_file_buffer(2,158000362,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(395,33),line_char(395,43))). -user:metta_file_buffer(1,158000362,metta_other,[->,'Atom','Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(395,13),line_char(395,44))). -user:metta_file_buffer(0,158000362,decl(ftype),[:,'cons-atom',[->,'Atom','Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(395,0),line_char(395,45))). -user:metta_file_buffer(0,159000362,indexed(metta_comment,"; AKA? (: cons (-> Atom Atom Atom))"),'$COMMENT'("; AKA? (: cons (-> Atom Atom Atom))",396,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(396,0),line_char(396,35))). -user:metta_file_buffer(1,159000363,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(398,1),line_char(398,3))). -user:metta_file_buffer(1,159000363,constant,'decons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(398,4),line_char(398,15))). -user:metta_file_buffer(1,159000363,constant,'MinimalMeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(398,16),line_char(398,28))). -user:metta_file_buffer(0,159000363,decl(impl),[iz,'decons-atom','MinimalMeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(398,0),line_char(398,29))). -user:metta_file_buffer(1,160000364,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(399,1),line_char(399,5))). -user:metta_file_buffer(1,160000364,constant,'decons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(399,6),line_char(399,17))). -user:metta_file_buffer(2,160000365,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(400,3),line_char(400,8))). -user:metta_file_buffer(2,160000365,string,"Works as a reverse to cons-atom function. It gets Expression as an input and returns it split into head and tail, e.g. (decons-atom (Cons X Nil)) -> (Cons (X Nil))",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(400,9),line_char(400,174))). -user:metta_file_buffer(1,160000365,metta_other,['@desc',"Works as a reverse to cons-atom function. It gets Expression as an input and returns it split into head and tail, e.g. (decons-atom (Cons X Nil)) -> (Cons (X Nil))"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(400,2),line_char(400,175))). -user:metta_file_buffer(2,160000366,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(401,3),line_char(401,10))). -user:metta_file_buffer(4,160000368,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(402,5),line_char(402,11))). -user:metta_file_buffer(4,160000368,string,"Expression to be Deconsed",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(402,12),line_char(402,39))). -user:metta_file_buffer(3,160000368,metta_other,['@param',"Expression to be Deconsed"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(402,4),line_char(402,40))). -user:metta_file_buffer(2,160000368,array,[['@param',"Expression to be Deconsed"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(401,11),line_char(402,41))). -user:metta_file_buffer(1,160000368,metta_other,['@params',[['@param',"Expression to be Deconsed"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(401,2),line_char(402,42))). -user:metta_file_buffer(2,160000369,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(403,3),line_char(403,10))). -user:metta_file_buffer(2,160000369,string,"Deconsed expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(403,11),line_char(403,32))). -user:metta_file_buffer(1,160000369,metta_other,['@return',"Deconsed expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(403,2),line_char(403,33))). -user:metta_file_buffer(0,160000369,decl(doc),['@doc','decons-atom',['@desc',"Works as a reverse to cons-atom function. It gets Expression as an input and returns it split into head and tail, e.g. (decons-atom (Cons X Nil)) -> (Cons (X Nil))"],['@params',[['@param',"Expression to be Deconsed"]]],['@return',"Deconsed expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(399,0),line_char(403,34))). -user:metta_file_buffer(1,161000370,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(404,1),line_char(404,2))). -user:metta_file_buffer(1,161000370,constant,'decons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(404,3),line_char(404,14))). -user:metta_file_buffer(2,161000371,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(404,16),line_char(404,18))). -user:metta_file_buffer(2,161000371,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(404,19),line_char(404,29))). -user:metta_file_buffer(2,161000371,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(404,30),line_char(404,40))). -user:metta_file_buffer(1,161000371,metta_other,[->,'Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(404,15),line_char(404,41))). -user:metta_file_buffer(0,161000371,decl(ftype),[:,'decons-atom',[->,'Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(404,0),line_char(404,42))). -user:metta_file_buffer(0,162000371,indexed(metta_comment,"; AKA? (: decons (-> Atom Atom))"),'$COMMENT'("; AKA? (: decons (-> Atom Atom))",405,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(405,0),line_char(405,32))). -user:metta_file_buffer(1,162000372,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(408,1),line_char(408,3))). -user:metta_file_buffer(1,162000372,constant,'min-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(408,4),line_char(408,12))). -user:metta_file_buffer(1,162000372,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(408,13),line_char(408,18))). -user:metta_file_buffer(0,162000372,decl(impl),[iz,'min-atom','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(408,0),line_char(408,19))). -user:metta_file_buffer(1,163000373,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(409,1),line_char(409,5))). -user:metta_file_buffer(1,163000373,constant,'min-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(409,6),line_char(409,14))). -user:metta_file_buffer(2,163000374,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(410,3),line_char(410,8))). -user:metta_file_buffer(2,163000374,string,"Returns atom with minimum value in the expression (first argument). Only numbers are allowed.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(410,9),line_char(410,104))). -user:metta_file_buffer(1,163000374,metta_other,['@desc',"Returns atom with minimum value in the expression (first argument). Only numbers are allowed."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(410,2),line_char(410,105))). -user:metta_file_buffer(2,163000375,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(411,3),line_char(411,10))). -user:metta_file_buffer(4,163000377,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(412,5),line_char(412,11))). -user:metta_file_buffer(4,163000377,string,"Expression containing atoms of Number type",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(412,12),line_char(412,56))). -user:metta_file_buffer(3,163000377,metta_other,['@param',"Expression containing atoms of Number type"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(412,4),line_char(412,57))). -user:metta_file_buffer(2,163000377,array,[['@param',"Expression containing atoms of Number type"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(411,11),line_char(412,58))). -user:metta_file_buffer(1,163000377,metta_other,['@params',[['@param',"Expression containing atoms of Number type"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(411,2),line_char(412,59))). -user:metta_file_buffer(2,163000378,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(413,3),line_char(413,10))). -user:metta_file_buffer(2,163000378,string,"Minimum value in the expression. Error if expression contains non-numeric value or is empty.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(413,11),line_char(413,105))). -user:metta_file_buffer(1,163000378,metta_other,['@return',"Minimum value in the expression. Error if expression contains non-numeric value or is empty."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(413,2),line_char(413,106))). -user:metta_file_buffer(0,163000378,decl(doc),['@doc','min-atom',['@desc',"Returns atom with minimum value in the expression (first argument). Only numbers are allowed."],['@params',[['@param',"Expression containing atoms of Number type"]]],['@return',"Minimum value in the expression. Error if expression contains non-numeric value or is empty."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(409,0),line_char(413,107))). -user:metta_file_buffer(1,164000379,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(414,1),line_char(414,2))). -user:metta_file_buffer(1,164000379,constant,'min-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(414,3),line_char(414,11))). -user:metta_file_buffer(2,164000380,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(414,13),line_char(414,15))). -user:metta_file_buffer(2,164000380,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(414,16),line_char(414,26))). -user:metta_file_buffer(2,164000380,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(414,27),line_char(414,33))). -user:metta_file_buffer(1,164000380,metta_other,[->,'Expression','Number'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(414,12),line_char(414,34))). -user:metta_file_buffer(0,164000380,decl(ftype),[:,'min-atom',[->,'Expression','Number']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(414,0),line_char(414,35))). -user:metta_file_buffer(1,165000381,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(415,1),line_char(415,2))). -user:metta_file_buffer(2,165000382,constant,'min-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(415,4),line_char(415,12))). -user:metta_file_buffer(2,165000382,variable,_57862,['L'=_57862],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(415,13),line_char(415,15))). -user:metta_file_buffer(1,165000382,indexed(metta_other,['min-atom',_58696]),['min-atom',_58748],['L'=_58748],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(415,3),line_char(415,16))). -user:metta_file_buffer(2,165000383,constant,'call-fn!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(415,18),line_char(415,26))). -user:metta_file_buffer(2,165000383,constant,min_list,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(415,27),line_char(415,35))). -user:metta_file_buffer(2,165000383,variable,_60956,['L'=_60956],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(415,36),line_char(415,38))). -user:metta_file_buffer(1,165000383,indexed(metta_directive,['call-fn!',min_list,_61804]),['call-fn!',min_list,_61862],['L'=_61862],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(415,17),line_char(415,39))). -user:metta_file_buffer(0,165000383,indexed(decl(impl),['min-atom',_62412]),[=,['min-atom',_62518],['call-fn!',min_list,_62518]],['L'=_62518],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(415,0),line_char(415,40))). -user:metta_file_buffer(1,166000384,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(417,1),line_char(417,3))). -user:metta_file_buffer(1,166000384,constant,'max-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(417,4),line_char(417,12))). -user:metta_file_buffer(1,166000384,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(417,13),line_char(417,18))). -user:metta_file_buffer(0,166000384,decl(impl),[iz,'max-atom','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(417,0),line_char(417,19))). -user:metta_file_buffer(1,167000385,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(418,1),line_char(418,5))). -user:metta_file_buffer(1,167000385,constant,'max-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(418,6),line_char(418,14))). -user:metta_file_buffer(2,167000386,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(419,3),line_char(419,8))). -user:metta_file_buffer(2,167000386,string,"Returns atom with maximum value in the expression (first argument). Only numbers are allowed.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(419,9),line_char(419,104))). -user:metta_file_buffer(1,167000386,metta_other,['@desc',"Returns atom with maximum value in the expression (first argument). Only numbers are allowed."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(419,2),line_char(419,105))). -user:metta_file_buffer(2,167000387,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(420,3),line_char(420,10))). -user:metta_file_buffer(4,167000389,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(421,5),line_char(421,11))). -user:metta_file_buffer(4,167000389,string,"Expression containing atoms of Number type",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(421,12),line_char(421,56))). -user:metta_file_buffer(3,167000389,metta_other,['@param',"Expression containing atoms of Number type"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(421,4),line_char(421,57))). -user:metta_file_buffer(2,167000389,array,[['@param',"Expression containing atoms of Number type"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(420,11),line_char(421,58))). -user:metta_file_buffer(1,167000389,metta_other,['@params',[['@param',"Expression containing atoms of Number type"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(420,2),line_char(421,59))). -user:metta_file_buffer(2,167000390,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(422,3),line_char(422,10))). -user:metta_file_buffer(2,167000390,string,"Maximum value in the expression. Error if expression contains non-numeric value or is empty.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(422,11),line_char(422,105))). -user:metta_file_buffer(1,167000390,metta_other,['@return',"Maximum value in the expression. Error if expression contains non-numeric value or is empty."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(422,2),line_char(422,106))). -user:metta_file_buffer(0,167000390,decl(doc),['@doc','max-atom',['@desc',"Returns atom with maximum value in the expression (first argument). Only numbers are allowed."],['@params',[['@param',"Expression containing atoms of Number type"]]],['@return',"Maximum value in the expression. Error if expression contains non-numeric value or is empty."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(418,0),line_char(422,107))). -user:metta_file_buffer(1,168000391,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(423,1),line_char(423,2))). -user:metta_file_buffer(1,168000391,constant,'max-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(423,3),line_char(423,11))). -user:metta_file_buffer(2,168000392,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(423,13),line_char(423,15))). -user:metta_file_buffer(2,168000392,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(423,16),line_char(423,26))). -user:metta_file_buffer(2,168000392,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(423,27),line_char(423,33))). -user:metta_file_buffer(1,168000392,metta_other,[->,'Expression','Number'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(423,12),line_char(423,34))). -user:metta_file_buffer(0,168000392,decl(ftype),[:,'max-atom',[->,'Expression','Number']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(423,0),line_char(423,35))). -user:metta_file_buffer(1,169000393,constant,'is-fn-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(424,1),line_char(424,8))). -user:metta_file_buffer(1,169000393,constant,'max-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(424,9),line_char(424,17))). -user:metta_file_buffer(1,169000393,constant,max_list,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(424,18),line_char(424,26))). -user:metta_file_buffer(0,169000393,decl(impl),['is-fn-1','max-atom',max_list],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(424,0),line_char(424,27))). -user:metta_file_buffer(1,170000394,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(426,1),line_char(426,3))). -user:metta_file_buffer(1,170000394,constant,'size-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(426,4),line_char(426,13))). -user:metta_file_buffer(1,170000394,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(426,14),line_char(426,19))). -user:metta_file_buffer(0,170000394,decl(impl),[iz,'size-atom','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(426,0),line_char(426,20))). -user:metta_file_buffer(1,171000395,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(427,1),line_char(427,5))). -user:metta_file_buffer(1,171000395,constant,'size-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(427,6),line_char(427,15))). -user:metta_file_buffer(2,171000396,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(428,3),line_char(428,8))). -user:metta_file_buffer(2,171000396,string,"Returns the size of an expression (first argument).",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(428,9),line_char(428,62))). -user:metta_file_buffer(1,171000396,metta_other,['@desc',"Returns the size of an expression (first argument)."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(428,2),line_char(428,63))). -user:metta_file_buffer(2,171000397,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(429,3),line_char(429,10))). -user:metta_file_buffer(4,171000399,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(430,5),line_char(430,11))). -user:metta_file_buffer(4,171000399,string,"Expression to measure the size of",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(430,12),line_char(430,47))). -user:metta_file_buffer(3,171000399,metta_other,['@param',"Expression to measure the size of"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(430,4),line_char(430,48))). -user:metta_file_buffer(2,171000399,array,[['@param',"Expression to measure the size of"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(429,11),line_char(430,49))). -user:metta_file_buffer(1,171000399,metta_other,['@params',[['@param',"Expression to measure the size of"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(429,2),line_char(430,50))). -user:metta_file_buffer(2,171000400,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(431,3),line_char(431,10))). -user:metta_file_buffer(2,171000400,string,"Size of the expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(431,11),line_char(431,35))). -user:metta_file_buffer(1,171000400,metta_other,['@return',"Size of the expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(431,2),line_char(431,36))). -user:metta_file_buffer(0,171000400,decl(doc),['@doc','size-atom',['@desc',"Returns the size of an expression (first argument)."],['@params',[['@param',"Expression to measure the size of"]]],['@return',"Size of the expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(427,0),line_char(431,37))). -user:metta_file_buffer(1,172000401,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(432,1),line_char(432,2))). -user:metta_file_buffer(1,172000401,constant,'size-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(432,3),line_char(432,12))). -user:metta_file_buffer(2,172000402,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(432,14),line_char(432,16))). -user:metta_file_buffer(2,172000402,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(432,17),line_char(432,27))). -user:metta_file_buffer(2,172000402,constant,'Integer',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(432,28),line_char(432,35))). -user:metta_file_buffer(1,172000402,metta_other,[->,'Expression','Integer'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(432,13),line_char(432,36))). -user:metta_file_buffer(0,172000402,decl(ftype),[:,'size-atom',[->,'Expression','Integer']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(432,0),line_char(432,37))). -user:metta_file_buffer(1,173000403,constant,'is-fn-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(433,1),line_char(433,8))). -user:metta_file_buffer(1,173000403,constant,'size-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(433,9),line_char(433,18))). -user:metta_file_buffer(1,173000403,constant,length,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(433,19),line_char(433,25))). -user:metta_file_buffer(0,173000403,decl(impl),['is-fn-1','size-atom',length],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(433,0),line_char(433,26))). -user:metta_file_buffer(1,174000404,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(435,1),line_char(435,3))). -user:metta_file_buffer(1,174000404,constant,'index-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(435,4),line_char(435,14))). -user:metta_file_buffer(1,174000404,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(435,15),line_char(435,20))). -user:metta_file_buffer(0,174000404,decl(impl),[iz,'index-atom','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(435,0),line_char(435,21))). -user:metta_file_buffer(1,175000405,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(436,1),line_char(436,5))). -user:metta_file_buffer(1,175000405,constant,'index-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(436,6),line_char(436,16))). -user:metta_file_buffer(2,175000406,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(437,3),line_char(437,8))). -user:metta_file_buffer(2,175000406,string,"Returns atom from an expression (first argument) using index (second argument) or error if index is out of bounds.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(437,9),line_char(437,125))). -user:metta_file_buffer(1,175000406,metta_other,['@desc',"Returns atom from an expression (first argument) using index (second argument) or error if index is out of bounds."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(437,2),line_char(437,126))). -user:metta_file_buffer(2,175000407,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(438,3),line_char(438,10))). -user:metta_file_buffer(4,175000409,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(439,5),line_char(439,11))). -user:metta_file_buffer(4,175000409,string,"Expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(439,12),line_char(439,24))). -user:metta_file_buffer(3,175000409,metta_other,['@param',"Expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(439,4),line_char(439,25))). -user:metta_file_buffer(4,175000410,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(440,5),line_char(440,11))). -user:metta_file_buffer(4,175000410,string,"Index",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(440,12),line_char(440,19))). -user:metta_file_buffer(3,175000410,metta_other,['@param',"Index"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(440,4),line_char(440,20))). -user:metta_file_buffer(2,175000410,array,[['@param',"Expression"],['@param',"Index"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(438,11),line_char(440,21))). -user:metta_file_buffer(1,175000410,metta_other,['@params',[['@param',"Expression"],['@param',"Index"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(438,2),line_char(440,22))). -user:metta_file_buffer(2,175000411,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(441,3),line_char(441,10))). -user:metta_file_buffer(2,175000411,string,"Atom at the specified index in the expression. Error if index is out of bounds.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(441,11),line_char(441,92))). -user:metta_file_buffer(1,175000411,metta_other,['@return',"Atom at the specified index in the expression. Error if index is out of bounds."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(441,2),line_char(441,93))). -user:metta_file_buffer(0,175000411,decl(doc),['@doc','index-atom',['@desc',"Returns atom from an expression (first argument) using index (second argument) or error if index is out of bounds."],['@params',[['@param',"Expression"],['@param',"Index"]]],['@return',"Atom at the specified index in the expression. Error if index is out of bounds."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(436,0),line_char(441,94))). -user:metta_file_buffer(1,176000412,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(442,1),line_char(442,2))). -user:metta_file_buffer(1,176000412,constant,'index-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(442,3),line_char(442,13))). -user:metta_file_buffer(2,176000413,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(442,15),line_char(442,17))). -user:metta_file_buffer(2,176000413,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(442,18),line_char(442,28))). -user:metta_file_buffer(2,176000413,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(442,29),line_char(442,35))). -user:metta_file_buffer(2,176000413,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(442,36),line_char(442,40))). -user:metta_file_buffer(1,176000413,metta_other,[->,'Expression','Number','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(442,14),line_char(442,41))). -user:metta_file_buffer(0,176000413,decl(ftype),[:,'index-atom',[->,'Expression','Number','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(442,0),line_char(442,42))). -user:metta_file_buffer(1,177000414,constant,'is-fn-21',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(443,1),line_char(443,9))). -user:metta_file_buffer(1,177000414,constant,'index-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(443,10),line_char(443,20))). -user:metta_file_buffer(1,177000414,constant,nth0,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(443,21),line_char(443,25))). -user:metta_file_buffer(0,177000414,decl(impl),['is-fn-21','index-atom',nth0],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(443,0),line_char(443,26))). -user:metta_file_buffer(0,178000414,indexed(metta_comment,";; ==> (= (index-atom $L $N) (call-fn! nth0 $N $L))"),'$COMMENT'(";; ==> (= (index-atom $L $N) (call-fn! nth0 $N $L))",444,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(444,0),line_char(444,51))). -user:metta_file_buffer(1,178000415,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(450,1),line_char(450,3))). -user:metta_file_buffer(1,178000415,constant,powi,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(450,4),line_char(450,8))). -user:metta_file_buffer(1,178000415,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(450,9),line_char(450,14))). -user:metta_file_buffer(0,178000415,decl(impl),[iz,powi,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(450,0),line_char(450,15))). -user:metta_file_buffer(1,179000416,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(451,1),line_char(451,5))). -user:metta_file_buffer(1,179000416,constant,powi,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(451,6),line_char(451,10))). -user:metta_file_buffer(2,179000417,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(452,3),line_char(452,8))). -user:metta_file_buffer(2,179000417,string,"Takes base (first argument) and power (second argument) and returns the result of raising the base to the power.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(452,9),line_char(452,123))). -user:metta_file_buffer(1,179000417,metta_other,['@desc',"Takes base (first argument) and power (second argument) and returns the result of raising the base to the power."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(452,2),line_char(452,124))). -user:metta_file_buffer(2,179000418,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(453,3),line_char(453,10))). -user:metta_file_buffer(4,179000420,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(454,5),line_char(454,11))). -user:metta_file_buffer(4,179000420,string,"Base. Could be a float.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(454,12),line_char(454,37))). -user:metta_file_buffer(3,179000420,metta_other,['@param',"Base. Could be a float."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(454,4),line_char(454,38))). -user:metta_file_buffer(4,179000421,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(455,5),line_char(455,11))). -user:metta_file_buffer(4,179000421,string,"Power. Must be an integer.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(455,12),line_char(455,40))). -user:metta_file_buffer(3,179000421,metta_other,['@param',"Power. Must be an integer."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(455,4),line_char(455,41))). -user:metta_file_buffer(2,179000421,array,[['@param',"Base. Could be a float."],['@param',"Power. Must be an integer."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(453,11),line_char(455,42))). -user:metta_file_buffer(1,179000421,metta_other,['@params',[['@param',"Base. Could be a float."],['@param',"Power. Must be an integer."]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(453,2),line_char(455,43))). -user:metta_file_buffer(2,179000422,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(456,3),line_char(456,10))). -user:metta_file_buffer(2,179000422,string,"Result of base raised to the power",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(456,11),line_char(456,47))). -user:metta_file_buffer(1,179000422,metta_other,['@return',"Result of base raised to the power"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(456,2),line_char(456,48))). -user:metta_file_buffer(0,179000422,decl(doc),['@doc',powi,['@desc',"Takes base (first argument) and power (second argument) and returns the result of raising the base to the power."],['@params',[['@param',"Base. Could be a float."],['@param',"Power. Must be an integer."]]],['@return',"Result of base raised to the power"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(451,0),line_char(456,49))). -user:metta_file_buffer(0,180000422,indexed(metta_comment,";(is-op-2 powi pow)"),'$COMMENT'(";(is-op-2 powi pow)",457,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(457,0),line_char(457,19))). -user:metta_file_buffer(1,180000423,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(458,1),line_char(458,2))). -user:metta_file_buffer(2,180000424,constant,powi,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(458,4),line_char(458,8))). -user:metta_file_buffer(2,180000424,variable,_62060,['B'=_62060],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(458,9),line_char(458,11))). -user:metta_file_buffer(2,180000424,variable,_63008,['P'=_63008],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(458,12),line_char(458,14))). -user:metta_file_buffer(1,180000424,indexed(metta_other,[powi,_63848,_63870]),[powi,_63922,_63928],['P'=_63928,'B'=_63922],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(458,3),line_char(458,15))). -user:metta_file_buffer(2,180000425,constant,'call-fn!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(458,17),line_char(458,25))). -user:metta_file_buffer(2,180000425,constant,pow,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(458,26),line_char(458,29))). -user:metta_file_buffer(2,180000425,variable,_66090,['B'=_66090],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(458,30),line_char(458,32))). -user:metta_file_buffer(2,180000425,variable,_67038,['P'=_67038],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(458,33),line_char(458,35))). -user:metta_file_buffer(1,180000425,indexed(metta_directive,['call-fn!',pow,_67892,_67914]),['call-fn!',pow,_67972,_67978],['P'=_67978,'B'=_67972],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(458,16),line_char(458,36))). -user:metta_file_buffer(0,180000425,indexed(decl(impl),[powi,_68540,_68562]),[=,[powi,_68686,_68692],['call-fn!',pow,_68686,_68692]],['P'=_68692,'B'=_68686],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(458,0),line_char(458,37))). -user:metta_file_buffer(1,181000426,constant,==>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(460,1),line_char(460,4))). -user:metta_file_buffer(2,181000427,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(460,6),line_char(460,13))). -user:metta_file_buffer(2,181000427,variable,_66930,['_m'=_66930],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(460,14),line_char(460,16))). -user:metta_file_buffer(2,181000427,variable,_68174,['_p'=_68174],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(460,17),line_char(460,19))). -user:metta_file_buffer(1,181000427,indexed(metta_other,['is-op-1',_69014,_69036]),['is-op-1',_69088,_69094],['_p'=_69094,'_m'=_69088],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(460,5),line_char(460,20))). -user:metta_file_buffer(2,181000428,constant,'is-fn-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(460,22),line_char(460,29))). -user:metta_file_buffer(2,181000428,variable,_70786,['_m'=_70786],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(460,30),line_char(460,32))). -user:metta_file_buffer(2,181000428,variable,_72030,['_p'=_72030],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(460,33),line_char(460,35))). -user:metta_file_buffer(1,181000428,indexed(metta_other,['is-fn-1',_72870,_72892]),['is-fn-1',_72944,_72950],['_p'=_72950,'_m'=_72944],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(460,21),line_char(460,36))). -user:metta_file_buffer(0,181000428,indexed(decl(impl),[==>,['is-op-1',_73506,_73528],['is-fn-1',_73506,_73528]]),[==>,['is-op-1',_73644,_73650],['is-fn-1',_73644,_73650]],['_p'=_73650,'_m'=_73644],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(460,0),line_char(460,37))). -user:metta_file_buffer(1,182000429,constant,==>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(461,1),line_char(461,4))). -user:metta_file_buffer(2,182000430,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(461,6),line_char(461,13))). -user:metta_file_buffer(2,182000430,variable,_66928,['_m'=_66928],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(461,14),line_char(461,16))). -user:metta_file_buffer(2,183000430,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(461,19),line_char(461,20))). -user:metta_file_buffer(3,184000431,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(461,22),line_char(461,23))). -user:metta_file_buffer(3,184000431,variable,_66622,['_m'=_66622],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(461,24),line_char(461,26))). -user:metta_file_buffer(4,184000432,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(461,28),line_char(461,30))). -user:metta_file_buffer(4,184000432,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(461,31),line_char(461,37))). -user:metta_file_buffer(4,184000432,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(461,38),line_char(461,44))). -user:metta_file_buffer(3,184000432,metta_other,[->,'Number','Number'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(461,27),line_char(461,45))). -user:metta_file_buffer(2,184000432,indexed(metta_typedecl,[:,_70010,[->,'Number','Number']]),[:,_70094,[->,'Number','Number']],['_m'=_70094],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(461,21),line_char(461,46))). -user:metta_file_buffer(2,185000432,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(461,46),line_char(461,47))). -user:metta_file_buffer(3,186000433,constant,==>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(462,1),line_char(462,4))). -user:metta_file_buffer(4,186000434,constant,'is-op-2',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(462,6),line_char(462,13))). -user:metta_file_buffer(4,186000434,variable,_67710,['_m'=_67710],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(462,14),line_char(462,16))). -user:metta_file_buffer(4,186000434,variable,_68954,['_p'=_68954],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(462,17),line_char(462,19))). -user:metta_file_buffer(3,186000434,indexed(metta_other,['is-op-2',_69794,_69816]),['is-op-2',_69868,_69874],['_p'=_69874,'_m'=_69868],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(462,5),line_char(462,20))). -user:metta_file_buffer(4,186000435,constant,'is-fn-2',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(462,22),line_char(462,29))). -user:metta_file_buffer(4,186000435,variable,_71566,['_m'=_71566],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(462,30),line_char(462,32))). -user:metta_file_buffer(4,186000435,variable,_72810,['_p'=_72810],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(462,33),line_char(462,35))). -user:metta_file_buffer(3,186000435,indexed(metta_other,['is-fn-2',_73650,_73672]),['is-fn-2',_73724,_73730],['_p'=_73730,'_m'=_73724],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(462,21),line_char(462,36))). -user:metta_file_buffer(2,186000435,indexed(metta_other,[==>,['is-op-2',_74286,_74308],['is-fn-2',_74286,_74308]]),[==>,['is-op-2',_74424,_74430],['is-fn-2',_74424,_74430]],['_p'=_74430,'_m'=_74424],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(462,0),line_char(462,37))). -user:metta_file_buffer(3,187000436,constant,==>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,1),line_char(463,4))). -user:metta_file_buffer(4,187000437,constant,'is-op-2',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,6),line_char(463,13))). -user:metta_file_buffer(4,187000437,variable,_67710,['_m'=_67710],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,14),line_char(463,16))). -user:metta_file_buffer(4,188000437,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,19),line_char(463,20))). -user:metta_file_buffer(5,189000438,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,22),line_char(463,23))). -user:metta_file_buffer(5,189000438,variable,_67404,['_m'=_67404],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,24),line_char(463,26))). -user:metta_file_buffer(6,189000439,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,28),line_char(463,30))). -user:metta_file_buffer(6,189000439,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,31),line_char(463,37))). -user:metta_file_buffer(6,189000439,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,38),line_char(463,44))). -user:metta_file_buffer(6,189000439,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,45),line_char(463,51))). -user:metta_file_buffer(5,189000439,metta_other,[->,'Number','Number','Number'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,27),line_char(463,52))). -user:metta_file_buffer(4,189000439,indexed(metta_typedecl,[:,_71414,[->,'Number','Number','Number']]),[:,_71506,[->,'Number','Number','Number']],['_m'=_71506],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,21),line_char(463,53))). -user:metta_file_buffer(4,190000439,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(463,53),line_char(463,54))). -user:metta_file_buffer(5,191000440,constant,==>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(464,1),line_char(464,4))). -user:metta_file_buffer(6,191000441,constant,'is-pred',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(464,6),line_char(464,13))). -user:metta_file_buffer(6,191000441,variable,_68492,['_m'=_68492],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(464,14),line_char(464,16))). -user:metta_file_buffer(6,191000441,variable,_69736,['_p'=_69736],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(464,17),line_char(464,19))). -user:metta_file_buffer(5,191000441,indexed(metta_other,['is-pred',_70576,_70598]),['is-pred',_70650,_70656],['_p'=_70656,'_m'=_70650],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(464,5),line_char(464,20))). -user:metta_file_buffer(6,191000442,constant,'is-pred-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(464,22),line_char(464,31))). -user:metta_file_buffer(6,191000442,variable,_72368,['_m'=_72368],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(464,32),line_char(464,34))). -user:metta_file_buffer(6,191000442,variable,_73612,['_p'=_73612],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(464,35),line_char(464,37))). -user:metta_file_buffer(5,191000442,indexed(metta_other,['is-pred-1',_74452,_74474]),['is-pred-1',_74526,_74532],['_p'=_74532,'_m'=_74526],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(464,21),line_char(464,38))). -user:metta_file_buffer(4,191000442,indexed(metta_other,[==>,['is-pred',_75088,_75110],['is-pred-1',_75088,_75110]]),[==>,['is-pred',_75226,_75232],['is-pred-1',_75226,_75232]],['_p'=_75232,'_m'=_75226],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(464,0),line_char(464,39))). -user:metta_file_buffer(5,192000443,constant,==>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(465,1),line_char(465,4))). -user:metta_file_buffer(6,192000444,constant,'is-pred',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(465,6),line_char(465,13))). -user:metta_file_buffer(6,192000444,variable,_68492,['_m'=_68492],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(465,14),line_char(465,16))). -user:metta_file_buffer(6,193000444,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(465,19),line_char(465,20))). -user:metta_file_buffer(7,194000445,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(465,22),line_char(465,23))). -user:metta_file_buffer(7,194000445,variable,_68186,['_m'=_68186],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(465,24),line_char(465,26))). -user:metta_file_buffer(8,194000446,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(465,28),line_char(465,30))). -user:metta_file_buffer(8,194000446,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(465,31),line_char(465,37))). -user:metta_file_buffer(8,194000446,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(465,38),line_char(465,42))). -user:metta_file_buffer(7,194000446,metta_other,[->,'Number','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(465,27),line_char(465,43))). -user:metta_file_buffer(6,194000446,indexed(metta_typedecl,[:,_71554,[->,'Number','Bool']]),[:,_71638,[->,'Number','Bool']],['_m'=_71638],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(465,21),line_char(465,44))). -user:metta_file_buffer(6,195000446,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(465,44),line_char(465,45))). -user:metta_file_buffer(7,196000447,constant,==>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,1),line_char(467,4))). -user:metta_file_buffer(8,196000448,constant,'is-fn-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,6),line_char(467,13))). -user:metta_file_buffer(8,196000448,variable,_69276,['_m'=_69276],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,14),line_char(467,16))). -user:metta_file_buffer(8,196000448,variable,_70520,['_p'=_70520],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,17),line_char(467,19))). -user:metta_file_buffer(7,196000448,indexed(metta_other,['is-fn-1',_71360,_71382]),['is-fn-1',_71434,_71440],['_p'=_71440,'_m'=_71434],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,5),line_char(467,20))). -user:metta_file_buffer(8,196000449,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,22),line_char(467,23))). -user:metta_file_buffer(9,196000450,variable,_73278,['_m'=_73278],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,25),line_char(467,27))). -user:metta_file_buffer(9,196000450,variable,_74522,['_a'=_74522],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,28),line_char(467,30))). -user:metta_file_buffer(8,196000450,indexed(metta_other,[_75348,_75370]),[_75416,_75422],['_a'=_75422,'_m'=_75416],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,24),line_char(467,31))). -user:metta_file_buffer(9,196000451,constant,'call-fn!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,33),line_char(467,41))). -user:metta_file_buffer(9,196000451,variable,_77234,['_p'=_77234],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,42),line_char(467,44))). -user:metta_file_buffer(9,196000451,variable,_78478,['_a'=_78478],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,45),line_char(467,47))). -user:metta_file_buffer(8,196000451,indexed(metta_directive,['call-fn!',_79318,_79340]),['call-fn!',_79392,_79398],['_a'=_79398,'_p'=_79392],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,32),line_char(467,48))). -user:metta_file_buffer(7,196000451,indexed(metta_defun,[_79952,_79974]),[=,[_80088,_80094],['call-fn!',_80112,_80094]],['_p'=_80112,'_a'=_80094,'_m'=_80088],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,21),line_char(467,49))). -user:metta_file_buffer(6,196000451,indexed(metta_other,[==>,['is-fn-1',_80686,_80708],[=,[_80686,_80772],['call-fn!',_80708,_80772]]]),[==>,['is-fn-1',_80888,_80894],[=,[_80888,_80924],['call-fn!',_80894,_80924]]],['_a'=_80924,'_p'=_80894,'_m'=_80888],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(467,0),line_char(467,50))). -user:metta_file_buffer(7,197000452,constant,==>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,1),line_char(468,4))). -user:metta_file_buffer(8,197000453,constant,'is-fn-r',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,6),line_char(468,13))). -user:metta_file_buffer(8,197000453,variable,_78422,['_m'=_78422],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,14),line_char(468,16))). -user:metta_file_buffer(8,197000453,variable,_79666,['_p'=_79666],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,17),line_char(468,19))). -user:metta_file_buffer(7,197000453,indexed(metta_other,['is-fn-r',_80506,_80528]),['is-fn-r',_80580,_80586],['_p'=_80586,'_m'=_80580],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,5),line_char(468,20))). -user:metta_file_buffer(8,197000454,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,22),line_char(468,23))). -user:metta_file_buffer(9,197000455,variable,_82424,['_m'=_82424],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,25),line_char(468,27))). -user:metta_file_buffer(9,197000455,variable,_83668,['_a'=_83668],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,28),line_char(468,30))). -user:metta_file_buffer(8,197000455,indexed(metta_other,[_84494,_84516]),[_84562,_84568],['_a'=_84568,'_m'=_84562],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,24),line_char(468,31))). -user:metta_file_buffer(9,197000456,constant,'call-fn-r!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,33),line_char(468,43))). -user:metta_file_buffer(9,197000456,variable,_86406,['_p'=_86406],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,44),line_char(468,46))). -user:metta_file_buffer(9,197000456,variable,_87650,['_a'=_87650],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,47),line_char(468,49))). -user:metta_file_buffer(8,197000456,indexed(metta_directive,['call-fn-r!',_88490,_88512]),['call-fn-r!',_88564,_88570],['_a'=_88570,'_p'=_88564],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,32),line_char(468,50))). -user:metta_file_buffer(7,197000456,indexed(metta_defun,[_89124,_89146]),[=,[_89260,_89266],['call-fn-r!',_89284,_89266]],['_p'=_89284,'_a'=_89266,'_m'=_89260],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,21),line_char(468,51))). -user:metta_file_buffer(6,197000456,indexed(metta_other,[==>,['is-fn-r',_89858,_89880],[=,[_89858,_89944],['call-fn-r!',_89880,_89944]]]),[==>,['is-fn-r',_90060,_90066],[=,[_90060,_90096],['call-fn-r!',_90066,_90096]]],['_a'=_90096,'_p'=_90066,'_m'=_90060],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(468,0),line_char(468,52))). -user:metta_file_buffer(7,198000457,constant,==>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,1),line_char(469,4))). -user:metta_file_buffer(8,198000458,constant,'is-fn-2',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,6),line_char(469,13))). -user:metta_file_buffer(8,198000458,variable,_87594,['_m'=_87594],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,14),line_char(469,16))). -user:metta_file_buffer(8,198000458,variable,_88838,['_p'=_88838],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,17),line_char(469,19))). -user:metta_file_buffer(7,198000458,indexed(metta_other,['is-fn-2',_89678,_89700]),['is-fn-2',_89752,_89758],['_p'=_89758,'_m'=_89752],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,5),line_char(469,20))). -user:metta_file_buffer(8,198000459,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,22),line_char(469,23))). -user:metta_file_buffer(9,198000460,variable,_91596,['_m'=_91596],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,25),line_char(469,27))). -user:metta_file_buffer(9,198000460,variable,_92832,['_a'=_92832],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,28),line_char(469,30))). -user:metta_file_buffer(9,198000460,variable,_94076,['_b'=_94076],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,31),line_char(469,33))). -user:metta_file_buffer(8,198000460,indexed(metta_other,[_94908,_94930,_94952]),[_94998,_95004,_95010],['_b'=_95010,'_a'=_95004,'_m'=_94998],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,24),line_char(469,34))). -user:metta_file_buffer(9,198000461,constant,'call-fn!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,36),line_char(469,44))). -user:metta_file_buffer(9,198000461,variable,_96834,['_p'=_96834],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,45),line_char(469,47))). -user:metta_file_buffer(9,198000461,variable,_98070,['_a'=_98070],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,48),line_char(469,50))). -user:metta_file_buffer(9,198000461,variable,_99314,['_b'=_99314],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,51),line_char(469,53))). -user:metta_file_buffer(8,198000461,indexed(metta_directive,['call-fn!',_100160,_100182,_100204]),['call-fn!',_100256,_100262,_100268],['_b'=_100268,'_a'=_100262,'_p'=_100256],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,35),line_char(469,54))). -user:metta_file_buffer(7,198000461,indexed(metta_defun,[_100834,_100856,_100878]),[=,[_101010,_101016,_101022],['call-fn!',_101040,_101016,_101022]],['_p'=_101040,'_b'=_101022,'_a'=_101016,'_m'=_101010],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,21),line_char(469,55))). -user:metta_file_buffer(6,198000461,indexed(metta_other,[==>,['is-fn-2',_101632,_101654],[=,[_101632,_101718,_101740],['call-fn!',_101654,_101718,_101740]]]),[==>,['is-fn-2',_101874,_101880],[=,[_101874,_101910,_101916],['call-fn!',_101880,_101910,_101916]]],['_b'=_101916,'_a'=_101910,'_p'=_101880,'_m'=_101874],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(469,0),line_char(469,56))). -user:metta_file_buffer(7,199000462,constant,==>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,1),line_char(470,4))). -user:metta_file_buffer(8,199000463,constant,'is-fn-21',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,6),line_char(470,14))). -user:metta_file_buffer(8,199000463,variable,_98032,['_m'=_98032],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,15),line_char(470,17))). -user:metta_file_buffer(8,199000463,variable,_99276,['_p'=_99276],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,18),line_char(470,20))). -user:metta_file_buffer(7,199000463,indexed(metta_other,['is-fn-21',_100116,_100138]),['is-fn-21',_100190,_100196],['_p'=_100196,'_m'=_100190],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,5),line_char(470,21))). -user:metta_file_buffer(8,199000464,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,23),line_char(470,24))). -user:metta_file_buffer(9,199000465,variable,_102034,['_m'=_102034],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,26),line_char(470,28))). -user:metta_file_buffer(9,199000465,variable,_102974,['L'=_102974],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,29),line_char(470,31))). -user:metta_file_buffer(9,199000465,variable,_103922,['N'=_103922],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,32),line_char(470,34))). -user:metta_file_buffer(8,199000465,indexed(metta_other,[_104754,_104776,_104798]),[_104844,_104850,_104856],['N'=_104856,'L'=_104850,'_m'=_104844],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,25),line_char(470,35))). -user:metta_file_buffer(9,199000466,constant,'call-fn!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,37),line_char(470,45))). -user:metta_file_buffer(9,199000466,variable,_106680,['_p'=_106680],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,46),line_char(470,48))). -user:metta_file_buffer(9,199000466,variable,_107620,['N'=_107620],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,49),line_char(470,51))). -user:metta_file_buffer(9,199000466,variable,_108568,['L'=_108568],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,52),line_char(470,54))). -user:metta_file_buffer(8,199000466,indexed(metta_directive,['call-fn!',_109414,_109436,_109458]),['call-fn!',_109510,_109516,_109522],['L'=_109522,'N'=_109516,'_p'=_109510],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,36),line_char(470,55))). -user:metta_file_buffer(7,199000466,indexed(metta_defun,[_110088,_110110,_110132]),[=,[_110264,_110270,_110276],['call-fn!',_110294,_110276,_110270]],['_p'=_110294,'N'=_110276,'L'=_110270,'_m'=_110264],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,22),line_char(470,56))). -user:metta_file_buffer(6,199000466,indexed(metta_other,[==>,['is-fn-21',_110886,_110908],[=,[_110886,_110972,_110994],['call-fn!',_110908,_110994,_110972]]]),[==>,['is-fn-21',_111128,_111134],[=,[_111128,_111164,_111170],['call-fn!',_111134,_111170,_111164]]],['N'=_111170,'L'=_111164,'_p'=_111134,'_m'=_111128],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(470,0),line_char(470,57))). -user:metta_file_buffer(7,200000467,constant,==>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,1),line_char(471,4))). -user:metta_file_buffer(8,200000468,constant,'is-pred-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,6),line_char(471,15))). -user:metta_file_buffer(8,200000468,variable,_107888,['_m'=_107888],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,16),line_char(471,18))). -user:metta_file_buffer(8,200000468,variable,_109132,['_p'=_109132],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,19),line_char(471,21))). -user:metta_file_buffer(7,200000468,indexed(metta_other,['is-pred-1',_109972,_109994]),['is-pred-1',_110046,_110052],['_p'=_110052,'_m'=_110046],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,5),line_char(471,22))). -user:metta_file_buffer(8,200000469,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,24),line_char(471,25))). -user:metta_file_buffer(9,200000470,variable,_111890,['_m'=_111890],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,27),line_char(471,29))). -user:metta_file_buffer(9,200000470,variable,_113134,['_a'=_113134],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,30),line_char(471,32))). -user:metta_file_buffer(8,200000470,indexed(metta_other,[_113960,_113982]),[_114028,_114034],['_a'=_114034,'_m'=_114028],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,26),line_char(471,33))). -user:metta_file_buffer(9,200000471,constant,'call-p!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,35),line_char(471,42))). -user:metta_file_buffer(9,200000471,variable,_115836,['_p'=_115836],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,43),line_char(471,45))). -user:metta_file_buffer(9,200000471,variable,_117080,['_a'=_117080],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,46),line_char(471,48))). -user:metta_file_buffer(8,200000471,indexed(metta_directive,['call-p!',_117920,_117942]),['call-p!',_117994,_118000],['_a'=_118000,'_p'=_117994],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,34),line_char(471,49))). -user:metta_file_buffer(7,200000471,indexed(metta_defun,[_118554,_118576]),[=,[_118690,_118696],['call-p!',_118714,_118696]],['_p'=_118714,'_a'=_118696,'_m'=_118690],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,23),line_char(471,50))). -user:metta_file_buffer(6,200000471,indexed(metta_other,[==>,['is-pred-1',_119288,_119310],[=,[_119288,_119374],['call-p!',_119310,_119374]]]),[==>,['is-pred-1',_119490,_119496],[=,[_119490,_119526],['call-p!',_119496,_119526]]],['_a'=_119526,'_p'=_119496,'_m'=_119490],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(471,0),line_char(471,51))). -user:metta_file_buffer(7,201000472,constant,==>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,1),line_char(472,4))). -user:metta_file_buffer(8,201000473,constant,'is-pred-2',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,6),line_char(472,15))). -user:metta_file_buffer(8,201000473,variable,_117044,['_m'=_117044],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,16),line_char(472,18))). -user:metta_file_buffer(8,201000473,variable,_118288,['_p'=_118288],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,19),line_char(472,21))). -user:metta_file_buffer(7,201000473,indexed(metta_other,['is-pred-2',_119128,_119150]),['is-pred-2',_119202,_119208],['_p'=_119208,'_m'=_119202],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,5),line_char(472,22))). -user:metta_file_buffer(8,201000474,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,24),line_char(472,25))). -user:metta_file_buffer(9,201000475,variable,_121046,['_m'=_121046],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,27),line_char(472,29))). -user:metta_file_buffer(9,201000475,variable,_122282,['_a'=_122282],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,30),line_char(472,32))). -user:metta_file_buffer(9,201000475,variable,_123526,['_b'=_123526],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,33),line_char(472,35))). -user:metta_file_buffer(8,201000475,indexed(metta_other,[_124358,_124380,_124402]),[_124448,_124454,_124460],['_b'=_124460,'_a'=_124454,'_m'=_124448],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,26),line_char(472,36))). -user:metta_file_buffer(9,201000476,constant,'call-p!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,38),line_char(472,45))). -user:metta_file_buffer(9,201000476,variable,_126274,['_p'=_126274],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,46),line_char(472,48))). -user:metta_file_buffer(9,201000476,variable,_127510,['_a'=_127510],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,49),line_char(472,51))). -user:metta_file_buffer(9,201000476,variable,_128754,['_b'=_128754],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,52),line_char(472,54))). -user:metta_file_buffer(8,201000476,indexed(metta_directive,['call-p!',_129600,_129622,_129644]),['call-p!',_129696,_129702,_129708],['_b'=_129708,'_a'=_129702,'_p'=_129696],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,37),line_char(472,55))). -user:metta_file_buffer(7,201000476,indexed(metta_defun,[_130274,_130296,_130318]),[=,[_130450,_130456,_130462],['call-p!',_130480,_130456,_130462]],['_p'=_130480,'_b'=_130462,'_a'=_130456,'_m'=_130450],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,23),line_char(472,56))). -user:metta_file_buffer(6,201000476,indexed(metta_other,[==>,['is-pred-2',_131072,_131094],[=,[_131072,_131158,_131180],['call-p!',_131094,_131158,_131180]]]),[==>,['is-pred-2',_131314,_131320],[=,[_131314,_131350,_131356],['call-p!',_131320,_131350,_131356]]],['_b'=_131356,'_a'=_131350,'_p'=_131320,'_m'=_131314],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(472,0),line_char(472,57))). -user:metta_file_buffer(7,202000477,constant,'is-fn-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(474,1),line_char(474,8))). -user:metta_file_buffer(7,202000477,constant,'py-list',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(474,9),line_char(474,16))). -user:metta_file_buffer(7,202000477,constant,py_list,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(474,17),line_char(474,24))). -user:metta_file_buffer(6,202000477,metta_other,['is-fn-1','py-list',py_list],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(474,0),line_char(474,25))). -user:metta_file_buffer(7,203000478,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(476,1),line_char(476,3))). -user:metta_file_buffer(7,203000478,constant,powf,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(476,4),line_char(476,8))). -user:metta_file_buffer(7,203000478,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(476,9),line_char(476,14))). -user:metta_file_buffer(6,203000478,metta_other,[iz,powf,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(476,0),line_char(476,15))). -user:metta_file_buffer(7,204000479,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(477,1),line_char(477,5))). -user:metta_file_buffer(7,204000479,constant,powf,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(477,6),line_char(477,10))). -user:metta_file_buffer(8,204000480,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(478,3),line_char(478,8))). -user:metta_file_buffer(8,204000480,string,"Takes base (first argument) and power (second argument) and returns the result of raising the base to the power.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(478,9),line_char(478,123))). -user:metta_file_buffer(7,204000480,metta_other,['@desc',"Takes base (first argument) and power (second argument) and returns the result of raising the base to the power."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(478,2),line_char(478,124))). -user:metta_file_buffer(8,204000481,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(479,3),line_char(479,10))). -user:metta_file_buffer(10,204000483,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(480,5),line_char(480,11))). -user:metta_file_buffer(10,204000483,string,"Base. Could be afloat.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(480,12),line_char(480,36))). -user:metta_file_buffer(9,204000483,metta_other,['@param',"Base. Could be afloat."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(480,4),line_char(480,37))). -user:metta_file_buffer(10,204000484,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(481,5),line_char(481,11))). -user:metta_file_buffer(10,204000484,string,"Power. Could be afloat.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(481,12),line_char(481,37))). -user:metta_file_buffer(9,204000484,metta_other,['@param',"Power. Could be afloat."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(481,4),line_char(481,38))). -user:metta_file_buffer(8,204000484,array,[['@param',"Base. Could be afloat."],['@param',"Power. Could be afloat."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(479,11),line_char(481,39))). -user:metta_file_buffer(7,204000484,metta_other,['@params',[['@param',"Base. Could be afloat."],['@param',"Power. Could be afloat."]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(479,2),line_char(481,40))). -user:metta_file_buffer(8,204000485,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(482,3),line_char(482,10))). -user:metta_file_buffer(8,204000485,string,"Result of base raisedtothepower ",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(482,11),line_char(482,45))). -user:metta_file_buffer(7,204000485,metta_other,['@return',"Result of base raisedtothepower "],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(482,2),line_char(482,46))). -user:metta_file_buffer(6,204000485,metta_other,['@doc',powf,['@desc',"Takes base (first argument) and power (second argument) and returns the result of raising the base to the power."],['@params',[['@param',"Base. Could be afloat."],['@param',"Power. Could be afloat."]]],['@return',"Result of base raisedtothepower "]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(477,0),line_char(482,47))). -user:metta_file_buffer(7,205000486,constant,'is-op-2',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(483,1),line_char(483,8))). -user:metta_file_buffer(7,205000486,constant,powf,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(483,9),line_char(483,13))). -user:metta_file_buffer(7,205000486,constant,pow,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(483,14),line_char(483,17))). -user:metta_file_buffer(6,205000486,metta_other,['is-op-2',powf,pow],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(483,0),line_char(483,18))). -user:metta_file_buffer(7,206000487,constant,'is-op-2',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(484,1),line_char(484,8))). -user:metta_file_buffer(7,206000487,constant,pow,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(484,9),line_char(484,12))). -user:metta_file_buffer(7,206000487,constant,pow,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(484,13),line_char(484,16))). -user:metta_file_buffer(6,206000487,metta_other,['is-op-2',pow,pow],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(484,0),line_char(484,17))). -user:metta_file_buffer(7,207000488,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(486,1),line_char(486,3))). -user:metta_file_buffer(7,207000488,constant,sqrt,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(486,4),line_char(486,8))). -user:metta_file_buffer(7,207000488,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(486,9),line_char(486,14))). -user:metta_file_buffer(6,207000488,metta_other,[iz,sqrt,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(486,0),line_char(486,15))). -user:metta_file_buffer(7,208000489,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(487,1),line_char(487,5))). -user:metta_file_buffer(7,208000489,constant,sqrt,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(487,6),line_char(487,10))). -user:metta_file_buffer(8,208000490,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(488,3),line_char(488,8))). -user:metta_file_buffer(8,208000490,string,"Returns square root for input number (first argument) which should be >= 0",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(488,9),line_char(488,85))). -user:metta_file_buffer(7,208000490,metta_other,['@desc',"Returns square root for input number (first argument) which should be >= 0"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(488,2),line_char(488,86))). -user:metta_file_buffer(8,208000491,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(489,3),line_char(489,10))). -user:metta_file_buffer(10,208000493,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(490,5),line_char(490,11))). -user:metta_file_buffer(10,208000493,string,"Input number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(490,12),line_char(490,26))). -user:metta_file_buffer(9,208000493,metta_other,['@param',"Input number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(490,4),line_char(490,27))). -user:metta_file_buffer(8,208000493,array,[['@param',"Input number"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(489,11),line_char(490,28))). -user:metta_file_buffer(7,208000493,metta_other,['@params',[['@param',"Input number"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(489,2),line_char(490,29))). -user:metta_file_buffer(8,208000494,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(491,3),line_char(491,10))). -user:metta_file_buffer(8,208000494,string,"Result of a square root function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(491,11),line_char(491,45))). -user:metta_file_buffer(7,208000494,metta_other,['@return',"Result of a square root function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(491,2),line_char(491,46))). -user:metta_file_buffer(6,208000494,metta_other,['@doc',sqrt,['@desc',"Returns square root for input number (first argument) which should be >= 0"],['@params',[['@param',"Input number"]]],['@return',"Result of a square root function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(487,0),line_char(491,47))). -user:metta_file_buffer(7,209000495,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(492,1),line_char(492,8))). -user:metta_file_buffer(7,209000495,constant,sqrt,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(492,9),line_char(492,13))). -user:metta_file_buffer(7,209000495,constant,sqrt,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(492,14),line_char(492,18))). -user:metta_file_buffer(6,209000495,metta_other,['is-op-1',sqrt,sqrt],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(492,0),line_char(492,19))). -user:metta_file_buffer(7,210000496,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(494,1),line_char(494,3))). -user:metta_file_buffer(7,210000496,constant,abs,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(494,4),line_char(494,7))). -user:metta_file_buffer(7,210000496,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(494,8),line_char(494,13))). -user:metta_file_buffer(6,210000496,metta_other,[iz,abs,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(494,0),line_char(494,14))). -user:metta_file_buffer(7,211000497,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(495,1),line_char(495,5))). -user:metta_file_buffer(7,211000497,constant,abs,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(495,6),line_char(495,9))). -user:metta_file_buffer(8,211000498,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(496,3),line_char(496,8))). -user:metta_file_buffer(8,211000498,string,"Returns absolute value of input number (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(496,9),line_char(496,66))). -user:metta_file_buffer(7,211000498,metta_other,['@desc',"Returns absolute value of input number (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(496,2),line_char(496,67))). -user:metta_file_buffer(8,211000499,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(497,3),line_char(497,10))). -user:metta_file_buffer(10,211000501,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(498,5),line_char(498,11))). -user:metta_file_buffer(10,211000501,string,"Input number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(498,12),line_char(498,26))). -user:metta_file_buffer(9,211000501,metta_other,['@param',"Input number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(498,4),line_char(498,27))). -user:metta_file_buffer(8,211000501,array,[['@param',"Input number"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(497,11),line_char(498,28))). -user:metta_file_buffer(7,211000501,metta_other,['@params',[['@param',"Input number"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(497,2),line_char(498,29))). -user:metta_file_buffer(8,211000502,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(499,3),line_char(499,10))). -user:metta_file_buffer(8,211000502,string,"Absolute value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(499,11),line_char(499,27))). -user:metta_file_buffer(7,211000502,metta_other,['@return',"Absolute value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(499,2),line_char(499,28))). -user:metta_file_buffer(6,211000502,metta_other,['@doc',abs,['@desc',"Returns absolute value of input number (first argument)"],['@params',[['@param',"Input number"]]],['@return',"Absolute value"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(495,0),line_char(499,29))). -user:metta_file_buffer(7,212000503,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(500,1),line_char(500,8))). -user:metta_file_buffer(7,212000503,constant,abs,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(500,9),line_char(500,12))). -user:metta_file_buffer(7,212000503,constant,abs,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(500,13),line_char(500,16))). -user:metta_file_buffer(6,212000503,metta_other,['is-op-1',abs,abs],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(500,0),line_char(500,17))). -user:metta_file_buffer(7,213000504,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(502,1),line_char(502,3))). -user:metta_file_buffer(7,213000504,constant,log,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(502,4),line_char(502,7))). -user:metta_file_buffer(7,213000504,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(502,8),line_char(502,13))). -user:metta_file_buffer(6,213000504,metta_other,[iz,log,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(502,0),line_char(502,14))). -user:metta_file_buffer(7,214000505,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(503,1),line_char(503,5))). -user:metta_file_buffer(7,214000505,constant,log,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(503,6),line_char(503,9))). -user:metta_file_buffer(8,214000506,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(504,3),line_char(504,8))). -user:metta_file_buffer(8,214000506,string,"Returns result of a logarithm function given base (first argument) and input number (second argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(504,9),line_char(504,112))). -user:metta_file_buffer(7,214000506,metta_other,['@desc',"Returns result of a logarithm function given base (first argument) and input number (second argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(504,2),line_char(504,113))). -user:metta_file_buffer(8,214000507,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(505,3),line_char(505,10))). -user:metta_file_buffer(10,214000509,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(506,5),line_char(506,11))). -user:metta_file_buffer(10,214000509,string,"Base",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(506,12),line_char(506,18))). -user:metta_file_buffer(9,214000509,metta_other,['@param',"Base"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(506,4),line_char(506,19))). -user:metta_file_buffer(10,214000510,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(507,5),line_char(507,11))). -user:metta_file_buffer(10,214000510,string,"Input number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(507,12),line_char(507,26))). -user:metta_file_buffer(9,214000510,metta_other,['@param',"Input number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(507,4),line_char(507,27))). -user:metta_file_buffer(8,214000510,array,[['@param',"Base"],['@param',"Input number"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(505,11),line_char(507,28))). -user:metta_file_buffer(7,214000510,metta_other,['@params',[['@param',"Base"],['@param',"Input number"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(505,2),line_char(507,29))). -user:metta_file_buffer(8,214000511,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(508,3),line_char(508,10))). -user:metta_file_buffer(8,214000511,string,"Result of log function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(508,11),line_char(508,35))). -user:metta_file_buffer(7,214000511,metta_other,['@return',"Result of log function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(508,2),line_char(508,36))). -user:metta_file_buffer(6,214000511,metta_other,['@doc',log,['@desc',"Returns result of a logarithm function given base (first argument) and input number (second argument)"],['@params',[['@param',"Base"],['@param',"Input number"]]],['@return',"Result of log function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(503,0),line_char(508,37))). -user:metta_file_buffer(7,215000512,constant,'is-op-2',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(509,1),line_char(509,8))). -user:metta_file_buffer(7,215000512,constant,log,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(509,9),line_char(509,12))). -user:metta_file_buffer(7,215000512,constant,log2,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(509,13),line_char(509,17))). -user:metta_file_buffer(6,215000512,metta_other,['is-op-2',log,log2],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(509,0),line_char(509,18))). -user:metta_file_buffer(7,216000513,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(511,1),line_char(511,3))). -user:metta_file_buffer(7,216000513,constant,trunc,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(511,4),line_char(511,9))). -user:metta_file_buffer(7,216000513,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(511,10),line_char(511,15))). -user:metta_file_buffer(6,216000513,metta_other,[iz,trunc,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(511,0),line_char(511,16))). -user:metta_file_buffer(7,217000514,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(512,1),line_char(512,5))). -user:metta_file_buffer(7,217000514,constant,trunc,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(512,6),line_char(512,11))). -user:metta_file_buffer(8,217000515,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(513,3),line_char(513,8))). -user:metta_file_buffer(8,217000515,string,"Returns integer part of the input value (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(513,9),line_char(513,67))). -user:metta_file_buffer(7,217000515,metta_other,['@desc',"Returns integer part of the input value (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(513,2),line_char(513,68))). -user:metta_file_buffer(8,217000516,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(514,3),line_char(514,10))). -user:metta_file_buffer(10,217000518,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(515,5),line_char(515,11))). -user:metta_file_buffer(10,217000518,string,"Float value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(515,12),line_char(515,25))). -user:metta_file_buffer(9,217000518,metta_other,['@param',"Float value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(515,4),line_char(515,26))). -user:metta_file_buffer(8,217000518,array,[['@param',"Float value"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(514,11),line_char(515,27))). -user:metta_file_buffer(7,217000518,metta_other,['@params',[['@param',"Float value"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(514,2),line_char(515,28))). -user:metta_file_buffer(8,217000519,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(516,3),line_char(516,10))). -user:metta_file_buffer(8,217000519,string,"Integer part of float",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(516,11),line_char(516,34))). -user:metta_file_buffer(7,217000519,metta_other,['@return',"Integer part of float"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(516,2),line_char(516,35))). -user:metta_file_buffer(6,217000519,metta_other,['@doc',trunc,['@desc',"Returns integer part of the input value (first argument)"],['@params',[['@param',"Float value"]]],['@return',"Integer part of float"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(512,0),line_char(516,36))). -user:metta_file_buffer(7,218000520,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(517,1),line_char(517,8))). -user:metta_file_buffer(7,218000520,constant,trunc,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(517,9),line_char(517,14))). -user:metta_file_buffer(7,218000520,constant,trunc,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(517,15),line_char(517,20))). -user:metta_file_buffer(6,218000520,metta_other,['is-op-1',trunc,trunc],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(517,0),line_char(517,21))). -user:metta_file_buffer(7,219000521,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(519,1),line_char(519,3))). -user:metta_file_buffer(7,219000521,constant,ceil,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(519,4),line_char(519,8))). -user:metta_file_buffer(7,219000521,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(519,9),line_char(519,14))). -user:metta_file_buffer(6,219000521,metta_other,[iz,ceil,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(519,0),line_char(519,15))). -user:metta_file_buffer(7,220000522,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(520,1),line_char(520,5))). -user:metta_file_buffer(7,220000522,constant,ceil,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(520,6),line_char(520,10))). -user:metta_file_buffer(8,220000523,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(521,3),line_char(521,8))). -user:metta_file_buffer(8,220000523,string,"Returns the smallest integer greater than or equal to the input value (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(521,9),line_char(521,97))). -user:metta_file_buffer(7,220000523,metta_other,['@desc',"Returns the smallest integer greater than or equal to the input value (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(521,2),line_char(521,98))). -user:metta_file_buffer(8,220000524,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(522,3),line_char(522,10))). -user:metta_file_buffer(10,220000526,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(523,5),line_char(523,11))). -user:metta_file_buffer(10,220000526,string,"Float value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(523,12),line_char(523,25))). -user:metta_file_buffer(9,220000526,metta_other,['@param',"Float value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(523,4),line_char(523,26))). -user:metta_file_buffer(8,220000526,array,[['@param',"Float value"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(522,11),line_char(523,27))). -user:metta_file_buffer(7,220000526,metta_other,['@params',[['@param',"Float value"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(522,2),line_char(523,28))). -user:metta_file_buffer(8,220000527,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(524,3),line_char(524,10))). -user:metta_file_buffer(8,220000527,string,"Integer value greater than or equal to the input",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(524,11),line_char(524,61))). -user:metta_file_buffer(7,220000527,metta_other,['@return',"Integer value greater than or equal to the input"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(524,2),line_char(524,62))). -user:metta_file_buffer(6,220000527,metta_other,['@doc',ceil,['@desc',"Returns the smallest integer greater than or equal to the input value (first argument)"],['@params',[['@param',"Float value"]]],['@return',"Integer value greater than or equal to the input"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(520,0),line_char(524,63))). -user:metta_file_buffer(7,221000528,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(525,1),line_char(525,8))). -user:metta_file_buffer(7,221000528,constant,ceil,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(525,9),line_char(525,13))). -user:metta_file_buffer(7,221000528,constant,ceil,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(525,14),line_char(525,18))). -user:metta_file_buffer(6,221000528,metta_other,['is-op-1',ceil,ceil],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(525,0),line_char(525,19))). -user:metta_file_buffer(7,222000529,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(527,1),line_char(527,3))). -user:metta_file_buffer(7,222000529,constant,floor,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(527,4),line_char(527,9))). -user:metta_file_buffer(7,222000529,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(527,10),line_char(527,15))). -user:metta_file_buffer(6,222000529,metta_other,[iz,floor,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(527,0),line_char(527,16))). -user:metta_file_buffer(7,223000530,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(528,1),line_char(528,5))). -user:metta_file_buffer(7,223000530,constant,floor,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(528,6),line_char(528,11))). -user:metta_file_buffer(8,223000531,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(529,3),line_char(529,8))). -user:metta_file_buffer(8,223000531,string,"Returns the smallest integer less than or equal to the input value (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(529,9),line_char(529,94))). -user:metta_file_buffer(7,223000531,metta_other,['@desc',"Returns the smallest integer less than or equal to the input value (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(529,2),line_char(529,95))). -user:metta_file_buffer(8,223000532,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(530,3),line_char(530,10))). -user:metta_file_buffer(10,223000534,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(531,5),line_char(531,11))). -user:metta_file_buffer(10,223000534,string,"Float value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(531,12),line_char(531,25))). -user:metta_file_buffer(9,223000534,metta_other,['@param',"Float value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(531,4),line_char(531,26))). -user:metta_file_buffer(8,223000534,array,[['@param',"Float value"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(530,11),line_char(531,27))). -user:metta_file_buffer(7,223000534,metta_other,['@params',[['@param',"Float value"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(530,2),line_char(531,28))). -user:metta_file_buffer(8,223000535,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(532,3),line_char(532,10))). -user:metta_file_buffer(8,223000535,string,"Integer value less than or equal to the input",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(532,11),line_char(532,58))). -user:metta_file_buffer(7,223000535,metta_other,['@return',"Integer value less than or equal to the input"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(532,2),line_char(532,59))). -user:metta_file_buffer(6,223000535,metta_other,['@doc',floor,['@desc',"Returns the smallest integer less than or equal to the input value (first argument)"],['@params',[['@param',"Float value"]]],['@return',"Integer value less than or equal to the input"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(528,0),line_char(532,60))). -user:metta_file_buffer(7,224000536,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(533,1),line_char(533,8))). -user:metta_file_buffer(7,224000536,constant,floor,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(533,9),line_char(533,14))). -user:metta_file_buffer(7,224000536,constant,floor,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(533,15),line_char(533,20))). -user:metta_file_buffer(6,224000536,metta_other,['is-op-1',floor,floor],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(533,0),line_char(533,21))). -user:metta_file_buffer(7,225000537,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(535,1),line_char(535,3))). -user:metta_file_buffer(7,225000537,constant,round,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(535,4),line_char(535,9))). -user:metta_file_buffer(7,225000537,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(535,10),line_char(535,15))). -user:metta_file_buffer(6,225000537,metta_other,[iz,round,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(535,0),line_char(535,16))). -user:metta_file_buffer(7,226000538,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(536,1),line_char(536,5))). -user:metta_file_buffer(7,226000538,constant,round,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(536,6),line_char(536,11))). -user:metta_file_buffer(8,226000539,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(537,3),line_char(537,8))). -user:metta_file_buffer(8,226000539,string,"Returns the nearest integer to the input float value (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(537,9),line_char(537,80))). -user:metta_file_buffer(7,226000539,metta_other,['@desc',"Returns the nearest integer to the input float value (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(537,2),line_char(537,81))). -user:metta_file_buffer(8,226000540,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(538,3),line_char(538,10))). -user:metta_file_buffer(10,226000542,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(539,5),line_char(539,11))). -user:metta_file_buffer(10,226000542,string,"Float value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(539,12),line_char(539,25))). -user:metta_file_buffer(9,226000542,metta_other,['@param',"Float value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(539,4),line_char(539,26))). -user:metta_file_buffer(8,226000542,array,[['@param',"Float value"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(538,11),line_char(539,27))). -user:metta_file_buffer(7,226000542,metta_other,['@params',[['@param',"Float value"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(538,2),line_char(539,28))). -user:metta_file_buffer(8,226000543,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(540,3),line_char(540,10))). -user:metta_file_buffer(8,226000543,string,"Nearest integer to the input",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(540,11),line_char(540,41))). -user:metta_file_buffer(7,226000543,metta_other,['@return',"Nearest integer to the input"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(540,2),line_char(540,42))). -user:metta_file_buffer(6,226000543,metta_other,['@doc',round,['@desc',"Returns the nearest integer to the input float value (first argument)"],['@params',[['@param',"Float value"]]],['@return',"Nearest integer to the input"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(536,0),line_char(540,43))). -user:metta_file_buffer(7,227000544,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(541,1),line_char(541,8))). -user:metta_file_buffer(7,227000544,constant,round,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(541,9),line_char(541,14))). -user:metta_file_buffer(7,227000544,constant,round,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(541,15),line_char(541,20))). -user:metta_file_buffer(6,227000544,metta_other,['is-op-1',round,round],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(541,0),line_char(541,21))). -user:metta_file_buffer(7,228000545,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(543,1),line_char(543,3))). -user:metta_file_buffer(7,228000545,constant,sin,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(543,4),line_char(543,7))). -user:metta_file_buffer(7,228000545,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(543,8),line_char(543,13))). -user:metta_file_buffer(6,228000545,metta_other,[iz,sin,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(543,0),line_char(543,14))). -user:metta_file_buffer(7,229000546,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(544,1),line_char(544,5))). -user:metta_file_buffer(7,229000546,constant,sin,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(544,6),line_char(544,9))). -user:metta_file_buffer(8,229000547,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(545,3),line_char(545,8))). -user:metta_file_buffer(8,229000547,string,"Returns result of the sine function for an input value in radians (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(545,9),line_char(545,93))). -user:metta_file_buffer(7,229000547,metta_other,['@desc',"Returns result of the sine function for an input value in radians (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(545,2),line_char(545,94))). -user:metta_file_buffer(8,229000548,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(546,3),line_char(546,10))). -user:metta_file_buffer(10,229000550,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(547,5),line_char(547,11))). -user:metta_file_buffer(10,229000550,string,"Angle in radians",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(547,12),line_char(547,30))). -user:metta_file_buffer(9,229000550,metta_other,['@param',"Angle in radians"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(547,4),line_char(547,31))). -user:metta_file_buffer(8,229000550,array,[['@param',"Angle in radians"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(546,11),line_char(547,32))). -user:metta_file_buffer(7,229000550,metta_other,['@params',[['@param',"Angle in radians"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(546,2),line_char(547,33))). -user:metta_file_buffer(8,229000551,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(548,3),line_char(548,10))). -user:metta_file_buffer(8,229000551,string,"Result of the sine function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(548,11),line_char(548,40))). -user:metta_file_buffer(7,229000551,metta_other,['@return',"Result of the sine function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(548,2),line_char(548,41))). -user:metta_file_buffer(6,229000551,metta_other,['@doc',sin,['@desc',"Returns result of the sine function for an input value in radians (first argument)"],['@params',[['@param',"Angle in radians"]]],['@return',"Result of the sine function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(544,0),line_char(548,42))). -user:metta_file_buffer(7,230000552,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(549,1),line_char(549,8))). -user:metta_file_buffer(7,230000552,constant,sin,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(549,9),line_char(549,12))). -user:metta_file_buffer(7,230000552,constant,sin,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(549,13),line_char(549,16))). -user:metta_file_buffer(6,230000552,metta_other,['is-op-1',sin,sin],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(549,0),line_char(549,17))). -user:metta_file_buffer(7,231000553,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(551,1),line_char(551,3))). -user:metta_file_buffer(7,231000553,constant,asin,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(551,4),line_char(551,8))). -user:metta_file_buffer(7,231000553,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(551,9),line_char(551,14))). -user:metta_file_buffer(6,231000553,metta_other,[iz,asin,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(551,0),line_char(551,15))). -user:metta_file_buffer(7,232000554,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(552,1),line_char(552,5))). -user:metta_file_buffer(7,232000554,constant,asin,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(552,6),line_char(552,10))). -user:metta_file_buffer(8,232000555,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(553,3),line_char(553,8))). -user:metta_file_buffer(8,232000555,string,"Returns result of the arcsine function for an input value (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(553,9),line_char(553,85))). -user:metta_file_buffer(7,232000555,metta_other,['@desc',"Returns result of the arcsine function for an input value (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(553,2),line_char(553,86))). -user:metta_file_buffer(8,232000556,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(554,3),line_char(554,10))). -user:metta_file_buffer(10,232000558,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(555,5),line_char(555,11))). -user:metta_file_buffer(10,232000558,string,"Float number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(555,12),line_char(555,26))). -user:metta_file_buffer(9,232000558,metta_other,['@param',"Float number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(555,4),line_char(555,27))). -user:metta_file_buffer(8,232000558,array,[['@param',"Float number"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(554,11),line_char(555,28))). -user:metta_file_buffer(7,232000558,metta_other,['@params',[['@param',"Float number"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(554,2),line_char(555,29))). -user:metta_file_buffer(8,232000559,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(556,3),line_char(556,10))). -user:metta_file_buffer(8,232000559,string,"Result of the arcsine function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(556,11),line_char(556,43))). -user:metta_file_buffer(7,232000559,metta_other,['@return',"Result of the arcsine function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(556,2),line_char(556,44))). -user:metta_file_buffer(6,232000559,metta_other,['@doc',asin,['@desc',"Returns result of the arcsine function for an input value (first argument)"],['@params',[['@param',"Float number"]]],['@return',"Result of the arcsine function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(552,0),line_char(556,45))). -user:metta_file_buffer(7,233000560,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(557,1),line_char(557,8))). -user:metta_file_buffer(7,233000560,constant,asin,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(557,9),line_char(557,13))). -user:metta_file_buffer(7,233000560,constant,asin,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(557,14),line_char(557,18))). -user:metta_file_buffer(6,233000560,metta_other,['is-op-1',asin,asin],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(557,0),line_char(557,19))). -user:metta_file_buffer(7,234000561,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(559,1),line_char(559,3))). -user:metta_file_buffer(7,234000561,constant,cos,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(559,4),line_char(559,7))). -user:metta_file_buffer(7,234000561,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(559,8),line_char(559,13))). -user:metta_file_buffer(6,234000561,metta_other,[iz,cos,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(559,0),line_char(559,14))). -user:metta_file_buffer(7,235000562,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(560,1),line_char(560,5))). -user:metta_file_buffer(7,235000562,constant,cos,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(560,6),line_char(560,9))). -user:metta_file_buffer(8,235000563,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(561,3),line_char(561,8))). -user:metta_file_buffer(8,235000563,string,"Returns result of the cosine function for an input value in radians (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(561,9),line_char(561,95))). -user:metta_file_buffer(7,235000563,metta_other,['@desc',"Returns result of the cosine function for an input value in radians (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(561,2),line_char(561,96))). -user:metta_file_buffer(8,235000564,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(562,3),line_char(562,10))). -user:metta_file_buffer(10,235000566,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(563,5),line_char(563,11))). -user:metta_file_buffer(10,235000566,string,"Angle in radians",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(563,12),line_char(563,30))). -user:metta_file_buffer(9,235000566,metta_other,['@param',"Angle in radians"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(563,4),line_char(563,31))). -user:metta_file_buffer(8,235000566,array,[['@param',"Angle in radians"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(562,11),line_char(563,32))). -user:metta_file_buffer(7,235000566,metta_other,['@params',[['@param',"Angle in radians"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(562,2),line_char(563,33))). -user:metta_file_buffer(8,235000567,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(564,3),line_char(564,10))). -user:metta_file_buffer(8,235000567,string,"Result of the cosine function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(564,11),line_char(564,42))). -user:metta_file_buffer(7,235000567,metta_other,['@return',"Result of the cosine function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(564,2),line_char(564,43))). -user:metta_file_buffer(6,235000567,metta_other,['@doc',cos,['@desc',"Returns result of the cosine function for an input value in radians (first argument)"],['@params',[['@param',"Angle in radians"]]],['@return',"Result of the cosine function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(560,0),line_char(564,44))). -user:metta_file_buffer(7,236000568,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(565,1),line_char(565,8))). -user:metta_file_buffer(7,236000568,constant,cos,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(565,9),line_char(565,12))). -user:metta_file_buffer(7,236000568,constant,cos,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(565,13),line_char(565,16))). -user:metta_file_buffer(6,236000568,metta_other,['is-op-1',cos,cos],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(565,0),line_char(565,17))). -user:metta_file_buffer(7,237000569,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(567,1),line_char(567,3))). -user:metta_file_buffer(7,237000569,constant,acos,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(567,4),line_char(567,8))). -user:metta_file_buffer(7,237000569,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(567,9),line_char(567,14))). -user:metta_file_buffer(6,237000569,metta_other,[iz,acos,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(567,0),line_char(567,15))). -user:metta_file_buffer(7,238000570,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(568,1),line_char(568,5))). -user:metta_file_buffer(7,238000570,constant,acos,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(568,6),line_char(568,10))). -user:metta_file_buffer(8,238000571,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(569,3),line_char(569,8))). -user:metta_file_buffer(8,238000571,string,"Returns result of the arccosine function for an input value (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(569,9),line_char(569,87))). -user:metta_file_buffer(7,238000571,metta_other,['@desc',"Returns result of the arccosine function for an input value (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(569,2),line_char(569,88))). -user:metta_file_buffer(8,238000572,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(570,3),line_char(570,10))). -user:metta_file_buffer(10,238000574,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(571,5),line_char(571,11))). -user:metta_file_buffer(10,238000574,string,"Float number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(571,12),line_char(571,26))). -user:metta_file_buffer(9,238000574,metta_other,['@param',"Float number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(571,4),line_char(571,27))). -user:metta_file_buffer(8,238000574,array,[['@param',"Float number"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(570,11),line_char(571,28))). -user:metta_file_buffer(7,238000574,metta_other,['@params',[['@param',"Float number"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(570,2),line_char(571,29))). -user:metta_file_buffer(8,238000575,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(572,3),line_char(572,10))). -user:metta_file_buffer(8,238000575,string,"Result of the arccosine function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(572,11),line_char(572,45))). -user:metta_file_buffer(7,238000575,metta_other,['@return',"Result of the arccosine function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(572,2),line_char(572,46))). -user:metta_file_buffer(6,238000575,metta_other,['@doc',acos,['@desc',"Returns result of the arccosine function for an input value (first argument)"],['@params',[['@param',"Float number"]]],['@return',"Result of the arccosine function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(568,0),line_char(572,47))). -user:metta_file_buffer(7,239000576,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(573,1),line_char(573,8))). -user:metta_file_buffer(7,239000576,constant,acos,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(573,9),line_char(573,13))). -user:metta_file_buffer(7,239000576,constant,acos,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(573,14),line_char(573,18))). -user:metta_file_buffer(6,239000576,metta_other,['is-op-1',acos,acos],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(573,0),line_char(573,19))). -user:metta_file_buffer(7,240000577,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(575,1),line_char(575,3))). -user:metta_file_buffer(7,240000577,constant,tan,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(575,4),line_char(575,7))). -user:metta_file_buffer(7,240000577,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(575,8),line_char(575,13))). -user:metta_file_buffer(6,240000577,metta_other,[iz,tan,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(575,0),line_char(575,14))). -user:metta_file_buffer(7,241000578,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(576,1),line_char(576,5))). -user:metta_file_buffer(7,241000578,constant,tan,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(576,6),line_char(576,9))). -user:metta_file_buffer(8,241000579,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(577,3),line_char(577,8))). -user:metta_file_buffer(8,241000579,string,"Returns result of the tangent function for an input value in radians (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(577,9),line_char(577,96))). -user:metta_file_buffer(7,241000579,metta_other,['@desc',"Returns result of the tangent function for an input value in radians (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(577,2),line_char(577,97))). -user:metta_file_buffer(8,241000580,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(578,3),line_char(578,10))). -user:metta_file_buffer(10,241000582,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(579,5),line_char(579,11))). -user:metta_file_buffer(10,241000582,string,"Angle in radians",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(579,12),line_char(579,30))). -user:metta_file_buffer(9,241000582,metta_other,['@param',"Angle in radians"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(579,4),line_char(579,31))). -user:metta_file_buffer(8,241000582,array,[['@param',"Angle in radians"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(578,11),line_char(579,32))). -user:metta_file_buffer(7,241000582,metta_other,['@params',[['@param',"Angle in radians"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(578,2),line_char(579,33))). -user:metta_file_buffer(8,241000583,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(580,3),line_char(580,10))). -user:metta_file_buffer(8,241000583,string,"Result of the tangent function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(580,11),line_char(580,43))). -user:metta_file_buffer(7,241000583,metta_other,['@return',"Result of the tangent function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(580,2),line_char(580,44))). -user:metta_file_buffer(6,241000583,metta_other,['@doc',tan,['@desc',"Returns result of the tangent function for an input value in radians (first argument)"],['@params',[['@param',"Angle in radians"]]],['@return',"Result of the tangent function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(576,0),line_char(580,45))). -user:metta_file_buffer(7,242000584,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(581,1),line_char(581,8))). -user:metta_file_buffer(7,242000584,constant,tan,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(581,9),line_char(581,12))). -user:metta_file_buffer(7,242000584,constant,tan,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(581,13),line_char(581,16))). -user:metta_file_buffer(6,242000584,metta_other,['is-op-1',tan,tan],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(581,0),line_char(581,17))). -user:metta_file_buffer(7,243000585,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(583,1),line_char(583,3))). -user:metta_file_buffer(7,243000585,constant,atan,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(583,4),line_char(583,8))). -user:metta_file_buffer(7,243000585,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(583,9),line_char(583,14))). -user:metta_file_buffer(6,243000585,metta_other,[iz,atan,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(583,0),line_char(583,15))). -user:metta_file_buffer(7,244000586,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(584,1),line_char(584,5))). -user:metta_file_buffer(7,244000586,constant,atan,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(584,6),line_char(584,10))). -user:metta_file_buffer(8,244000587,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(585,3),line_char(585,8))). -user:metta_file_buffer(8,244000587,string,"Returns result of the arctangent function for an input value (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(585,9),line_char(585,88))). -user:metta_file_buffer(7,244000587,metta_other,['@desc',"Returns result of the arctangent function for an input value (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(585,2),line_char(585,89))). -user:metta_file_buffer(8,244000588,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(586,3),line_char(586,10))). -user:metta_file_buffer(10,244000590,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(587,5),line_char(587,11))). -user:metta_file_buffer(10,244000590,string,"Float number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(587,12),line_char(587,26))). -user:metta_file_buffer(9,244000590,metta_other,['@param',"Float number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(587,4),line_char(587,27))). -user:metta_file_buffer(8,244000590,array,[['@param',"Float number"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(586,11),line_char(587,28))). -user:metta_file_buffer(7,244000590,metta_other,['@params',[['@param',"Float number"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(586,2),line_char(587,29))). -user:metta_file_buffer(8,244000591,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(588,3),line_char(588,10))). -user:metta_file_buffer(8,244000591,string,"Result of the tangent function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(588,11),line_char(588,43))). -user:metta_file_buffer(7,244000591,metta_other,['@return',"Result of the tangent function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(588,2),line_char(588,44))). -user:metta_file_buffer(6,244000591,metta_other,['@doc',atan,['@desc',"Returns result of the arctangent function for an input value (first argument)"],['@params',[['@param',"Float number"]]],['@return',"Result of the tangent function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(584,0),line_char(588,45))). -user:metta_file_buffer(7,245000592,constant,'is-op-1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(589,1),line_char(589,8))). -user:metta_file_buffer(7,245000592,constant,atan,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(589,9),line_char(589,13))). -user:metta_file_buffer(7,245000592,constant,atan,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(589,14),line_char(589,18))). -user:metta_file_buffer(6,245000592,metta_other,['is-op-1',atan,atan],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(589,0),line_char(589,19))). -user:metta_file_buffer(7,246000593,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(591,1),line_char(591,3))). -user:metta_file_buffer(7,246000593,constant,isnan,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(591,4),line_char(591,9))). -user:metta_file_buffer(7,246000593,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(591,10),line_char(591,15))). -user:metta_file_buffer(6,246000593,metta_other,[iz,isnan,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(591,0),line_char(591,16))). -user:metta_file_buffer(7,247000594,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(592,1),line_char(592,5))). -user:metta_file_buffer(7,247000594,constant,isnan,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(592,6),line_char(592,11))). -user:metta_file_buffer(8,247000595,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(593,3),line_char(593,8))). -user:metta_file_buffer(8,247000595,string,"Returns True if input value is NaN. False - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(593,9),line_char(593,64))). -user:metta_file_buffer(7,247000595,metta_other,['@desc',"Returns True if input value is NaN. False - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(593,2),line_char(593,65))). -user:metta_file_buffer(8,247000596,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(594,3),line_char(594,10))). -user:metta_file_buffer(10,247000598,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(595,5),line_char(595,11))). -user:metta_file_buffer(10,247000598,string,"Number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(595,12),line_char(595,20))). -user:metta_file_buffer(9,247000598,metta_other,['@param',"Number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(595,4),line_char(595,21))). -user:metta_file_buffer(8,247000598,array,[['@param',"Number"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(594,11),line_char(595,22))). -user:metta_file_buffer(7,247000598,metta_other,['@params',[['@param',"Number"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(594,2),line_char(595,23))). -user:metta_file_buffer(8,247000599,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(596,3),line_char(596,10))). -user:metta_file_buffer(8,247000599,string,"True/False",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(596,11),line_char(596,23))). -user:metta_file_buffer(7,247000599,metta_other,['@return',"True/False"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(596,2),line_char(596,24))). -user:metta_file_buffer(6,247000599,metta_other,['@doc',isnan,['@desc',"Returns True if input value is NaN. False - otherwise"],['@params',[['@param',"Number"]]],['@return',"True/False"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(592,0),line_char(596,25))). -user:metta_file_buffer(7,248000600,constant,'is-pred',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(597,1),line_char(597,8))). -user:metta_file_buffer(7,248000600,constant,isnan,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(597,9),line_char(597,14))). -user:metta_file_buffer(7,248000600,constant,is_NaN,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(597,15),line_char(597,21))). -user:metta_file_buffer(6,248000600,metta_other,['is-pred',isnan,is_NaN],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(597,0),line_char(597,22))). -user:metta_file_buffer(7,249000601,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(599,1),line_char(599,3))). -user:metta_file_buffer(7,249000601,constant,isinf,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(599,4),line_char(599,9))). -user:metta_file_buffer(7,249000601,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(599,10),line_char(599,15))). -user:metta_file_buffer(6,249000601,metta_other,[iz,isinf,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(599,0),line_char(599,16))). -user:metta_file_buffer(7,250000602,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(600,1),line_char(600,5))). -user:metta_file_buffer(7,250000602,constant,isinf,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(600,6),line_char(600,11))). -user:metta_file_buffer(8,250000603,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(601,3),line_char(601,8))). -user:metta_file_buffer(8,250000603,string,"Returns True if input value is positive or negative infinity. False - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(601,9),line_char(601,90))). -user:metta_file_buffer(7,250000603,metta_other,['@desc',"Returns True if input value is positive or negative infinity. False - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(601,2),line_char(601,91))). -user:metta_file_buffer(8,250000604,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(602,3),line_char(602,10))). -user:metta_file_buffer(10,250000606,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(603,5),line_char(603,11))). -user:metta_file_buffer(10,250000606,string,"Number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(603,12),line_char(603,20))). -user:metta_file_buffer(9,250000606,metta_other,['@param',"Number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(603,4),line_char(603,21))). -user:metta_file_buffer(8,250000606,array,[['@param',"Number"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(602,11),line_char(603,22))). -user:metta_file_buffer(7,250000606,metta_other,['@params',[['@param',"Number"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(602,2),line_char(603,23))). -user:metta_file_buffer(8,250000607,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(604,3),line_char(604,10))). -user:metta_file_buffer(8,250000607,string,"True/False",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(604,11),line_char(604,23))). -user:metta_file_buffer(7,250000607,metta_other,['@return',"True/False"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(604,2),line_char(604,24))). -user:metta_file_buffer(6,250000607,metta_other,['@doc',isinf,['@desc',"Returns True if input value is positive or negative infinity. False - otherwise"],['@params',[['@param',"Number"]]],['@return',"True/False"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(600,0),line_char(604,25))). -user:metta_file_buffer(6,251000607,indexed(metta_comment,"; this is deduced: (: isinf (-> Number Bool))"),'$COMMENT'("; this is deduced: (: isinf (-> Number Bool))",605,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(605,0),line_char(605,45))). -user:metta_file_buffer(7,251000608,constant,'is-pred',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(606,1),line_char(606,8))). -user:metta_file_buffer(7,251000608,constant,isinf,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(606,9),line_char(606,14))). -user:metta_file_buffer(7,251000608,constant,is_Inf,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(606,15),line_char(606,21))). -user:metta_file_buffer(6,251000608,metta_other,['is-pred',isinf,is_Inf],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(606,0),line_char(606,22))). -user:metta_file_buffer(7,252000609,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(608,1),line_char(608,3))). -user:metta_file_buffer(7,252000609,constant,'random-int',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(608,4),line_char(608,14))). -user:metta_file_buffer(7,252000609,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(608,15),line_char(608,20))). -user:metta_file_buffer(6,252000609,metta_other,[iz,'random-int','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(608,0),line_char(608,21))). -user:metta_file_buffer(7,253000610,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(609,1),line_char(609,5))). -user:metta_file_buffer(7,253000610,constant,'random-int',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(609,6),line_char(609,16))). -user:metta_file_buffer(8,253000611,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(610,3),line_char(610,8))). -user:metta_file_buffer(8,253000611,string,"Returns random int number from range defined by two numbers (first and second argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(610,9),line_char(610,98))). -user:metta_file_buffer(7,253000611,metta_other,['@desc',"Returns random int number from range defined by two numbers (first and second argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(610,2),line_char(610,99))). -user:metta_file_buffer(8,253000612,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(611,3),line_char(611,10))). -user:metta_file_buffer(10,253000614,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(612,5),line_char(612,11))). -user:metta_file_buffer(10,253000614,string,"Range start",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(612,12),line_char(612,25))). -user:metta_file_buffer(9,253000614,metta_other,['@param',"Range start"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(612,4),line_char(612,26))). -user:metta_file_buffer(10,253000615,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(613,5),line_char(613,11))). -user:metta_file_buffer(10,253000615,string,"Range end",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(613,12),line_char(613,23))). -user:metta_file_buffer(9,253000615,metta_other,['@param',"Range end"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(613,4),line_char(613,24))). -user:metta_file_buffer(8,253000615,array,[['@param',"Range start"],['@param',"Range end"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(611,11),line_char(613,25))). -user:metta_file_buffer(7,253000615,metta_other,['@params',[['@param',"Range start"],['@param',"Range end"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(611,2),line_char(613,26))). -user:metta_file_buffer(8,253000616,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(614,3),line_char(614,10))). -user:metta_file_buffer(8,253000616,string,"Random int number from defined range",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(614,11),line_char(614,49))). -user:metta_file_buffer(7,253000616,metta_other,['@return',"Random int number from defined range"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(614,2),line_char(614,50))). -user:metta_file_buffer(6,253000616,metta_other,['@doc','random-int',['@desc',"Returns random int number from range defined by two numbers (first and second argument)"],['@params',[['@param',"Range start"],['@param',"Range end"]]],['@return',"Random int number from defined range"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(609,0),line_char(614,51))). -user:metta_file_buffer(7,254000617,constant,'is-op-2',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(615,1),line_char(615,8))). -user:metta_file_buffer(7,254000617,constant,'random-int',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(615,9),line_char(615,19))). -user:metta_file_buffer(7,254000617,constant,random,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(615,20),line_char(615,26))). -user:metta_file_buffer(6,254000617,metta_other,['is-op-2','random-int',random],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(615,0),line_char(615,27))). -user:metta_file_buffer(7,255000618,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(617,1),line_char(617,3))). -user:metta_file_buffer(7,255000618,constant,'random-float',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(617,4),line_char(617,16))). -user:metta_file_buffer(7,255000618,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(617,17),line_char(617,22))). -user:metta_file_buffer(6,255000618,metta_other,[iz,'random-float','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(617,0),line_char(617,23))). -user:metta_file_buffer(7,256000619,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(618,1),line_char(618,5))). -user:metta_file_buffer(7,256000619,constant,'random-float',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(618,6),line_char(618,18))). -user:metta_file_buffer(8,256000620,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(619,3),line_char(619,8))). -user:metta_file_buffer(8,256000620,string,"Returns random float number from range defined by two numbers (first and second argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(619,9),line_char(619,100))). -user:metta_file_buffer(7,256000620,metta_other,['@desc',"Returns random float number from range defined by two numbers (first and second argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(619,2),line_char(619,101))). -user:metta_file_buffer(8,256000621,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(620,3),line_char(620,10))). -user:metta_file_buffer(10,256000623,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(621,5),line_char(621,11))). -user:metta_file_buffer(10,256000623,string,"Range start",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(621,12),line_char(621,25))). -user:metta_file_buffer(9,256000623,metta_other,['@param',"Range start"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(621,4),line_char(621,26))). -user:metta_file_buffer(10,256000624,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(622,5),line_char(622,11))). -user:metta_file_buffer(10,256000624,string,"Range end",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(622,12),line_char(622,23))). -user:metta_file_buffer(9,256000624,metta_other,['@param',"Range end"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(622,4),line_char(622,24))). -user:metta_file_buffer(8,256000624,array,[['@param',"Range start"],['@param',"Range end"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(620,11),line_char(622,25))). -user:metta_file_buffer(7,256000624,metta_other,['@params',[['@param',"Range start"],['@param',"Range end"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(620,2),line_char(622,26))). -user:metta_file_buffer(8,256000625,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(623,3),line_char(623,10))). -user:metta_file_buffer(8,256000625,string,"Random float number from defined range",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(623,11),line_char(623,51))). -user:metta_file_buffer(7,256000625,metta_other,['@return',"Random float number from defined range"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(623,2),line_char(623,52))). -user:metta_file_buffer(6,256000625,metta_other,['@doc','random-float',['@desc',"Returns random float number from range defined by two numbers (first and second argument)"],['@params',[['@param',"Range start"],['@param',"Range end"]]],['@return',"Random float number from defined range"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(618,0),line_char(623,53))). -user:metta_file_buffer(7,257000626,constant,'is-op-2',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(624,1),line_char(624,8))). -user:metta_file_buffer(7,257000626,constant,'random-int',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(624,9),line_char(624,19))). -user:metta_file_buffer(7,257000626,constant,random,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(624,20),line_char(624,26))). -user:metta_file_buffer(6,257000626,metta_other,['is-op-2','random-int',random],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(624,0),line_char(624,27))). -user:metta_file_buffer(7,258000627,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(626,1),line_char(626,3))). -user:metta_file_buffer(7,258000627,constant,'collapse-bind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(626,4),line_char(626,17))). -user:metta_file_buffer(7,258000627,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(626,18),line_char(626,23))). -user:metta_file_buffer(6,258000627,metta_other,[iz,'collapse-bind','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(626,0),line_char(626,24))). -user:metta_file_buffer(7,259000628,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(627,1),line_char(627,5))). -user:metta_file_buffer(7,259000628,constant,'collapse-bind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(627,6),line_char(627,19))). -user:metta_file_buffer(8,259000629,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(628,3),line_char(628,8))). -user:metta_file_buffer(8,259000629,string,"Evaluates the Atom (first argument) and returns an expression which contains all alternative evaluations in a form (Atom Bindings). Bindings are represented in a form of a grounded atom { <- , ... }. See also the complement superpose-bind. Note that, like chain, collapse-bind only evaluates Minimal Metta expressions. Evaluation of non-Minimal MeTTa atoms can be controlled by wrapping in a call to eval (for one evaluation step) or metta (for full evaluation).",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(628,9),line_char(628,488))). -user:metta_file_buffer(7,259000629,metta_other,['@desc',"Evaluates the Atom (first argument) and returns an expression which contains all alternative evaluations in a form (Atom Bindings). Bindings are represented in a form of a grounded atom { <- , ... }. See also the complement superpose-bind. Note that, like chain, collapse-bind only evaluates Minimal Metta expressions. Evaluation of non-Minimal MeTTa atoms can be controlled by wrapping in a call to eval (for one evaluation step) or metta (for full evaluation)."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(628,2),line_char(628,489))). -user:metta_file_buffer(8,259000630,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(629,3),line_char(629,10))). -user:metta_file_buffer(10,259000632,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(630,5),line_char(630,11))). -user:metta_file_buffer(10,259000632,string,"Atom to be evaluated",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(630,12),line_char(630,34))). -user:metta_file_buffer(9,259000632,metta_other,['@param',"Atom to be evaluated"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(630,4),line_char(630,35))). -user:metta_file_buffer(8,259000632,array,[['@param',"Atom to be evaluated"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(629,11),line_char(630,36))). -user:metta_file_buffer(7,259000632,metta_other,['@params',[['@param',"Atom to be evaluated"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(629,2),line_char(630,37))). -user:metta_file_buffer(8,259000633,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(631,3),line_char(631,10))). -user:metta_file_buffer(8,259000633,string,"All alternative evaluations",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(631,11),line_char(631,40))). -user:metta_file_buffer(7,259000633,metta_other,['@return',"All alternative evaluations"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(631,2),line_char(631,41))). -user:metta_file_buffer(6,259000633,metta_other,['@doc','collapse-bind',['@desc',"Evaluates the Atom (first argument) and returns an expression which contains all alternative evaluations in a form (Atom Bindings). Bindings are represented in a form of a grounded atom { <- , ... }. See also the complement superpose-bind. Note that, like chain, collapse-bind only evaluates Minimal Metta expressions. Evaluation of non-Minimal MeTTa atoms can be controlled by wrapping in a call to eval (for one evaluation step) or metta (for full evaluation)."],['@params',[['@param',"Atom to be evaluated"]]],['@return',"All alternative evaluations"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(627,0),line_char(631,42))). -user:metta_file_buffer(6,260000633,indexed(metta_comment,";; collapse-bind because `collapse` doesnt guarantee shared bindings"),'$COMMENT'(";; collapse-bind because `collapse` doesnt guarantee shared bindings",632,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(632,0),line_char(632,68))). -user:metta_file_buffer(7,260000634,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(633,1),line_char(633,2))). -user:metta_file_buffer(7,260000634,constant,'collapse-bind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(633,3),line_char(633,16))). -user:metta_file_buffer(8,260000635,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(633,18),line_char(633,20))). -user:metta_file_buffer(8,260000635,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(633,21),line_char(633,25))). -user:metta_file_buffer(8,260000635,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(633,26),line_char(633,36))). -user:metta_file_buffer(7,260000635,metta_other,[->,'Atom','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(633,17),line_char(633,37))). -user:metta_file_buffer(6,260000635,metta_typedecl,[:,'collapse-bind',[->,'Atom','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(633,0),line_char(633,38))). -user:metta_file_buffer(7,261000636,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(635,1),line_char(635,3))). -user:metta_file_buffer(7,261000636,constant,'superpose-bind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(635,4),line_char(635,18))). -user:metta_file_buffer(7,261000636,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(635,19),line_char(635,24))). -user:metta_file_buffer(6,261000636,metta_other,[iz,'superpose-bind','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(635,0),line_char(635,25))). -user:metta_file_buffer(7,262000637,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(636,1),line_char(636,5))). -user:metta_file_buffer(7,262000637,constant,'superpose-bind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(636,6),line_char(636,20))). -user:metta_file_buffer(8,262000638,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(637,3),line_char(637,8))). -user:metta_file_buffer(8,262000638,string,"Complement to the collapse-bind. It takes result of collapse-bind (first argument) and returns only result atoms without bindings. Primarily used with some filtering step on the collapse-bind results, i.e. collapse-bind -> -> superpose-bind.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(637,9),line_char(637,261))). -user:metta_file_buffer(7,262000638,metta_other,['@desc',"Complement to the collapse-bind. It takes result of collapse-bind (first argument) and returns only result atoms without bindings. Primarily used with some filtering step on the collapse-bind results, i.e. collapse-bind -> -> superpose-bind."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(637,2),line_char(637,262))). -user:metta_file_buffer(8,262000639,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(638,3),line_char(638,10))). -user:metta_file_buffer(10,262000641,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(639,5),line_char(639,11))). -user:metta_file_buffer(10,262000641,string,"Expression in form (Atom Binding)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(639,12),line_char(639,47))). -user:metta_file_buffer(9,262000641,metta_other,['@param',"Expression in form (Atom Binding)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(639,4),line_char(639,48))). -user:metta_file_buffer(8,262000641,array,[['@param',"Expression in form (Atom Binding)"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(638,11),line_char(639,49))). -user:metta_file_buffer(7,262000641,metta_other,['@params',[['@param',"Expression in form (Atom Binding)"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(638,2),line_char(639,50))). -user:metta_file_buffer(8,262000642,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(640,3),line_char(640,10))). -user:metta_file_buffer(8,262000642,string,"Non-deterministic list of Atoms",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(640,11),line_char(640,44))). -user:metta_file_buffer(7,262000642,metta_other,['@return',"Non-deterministic list of Atoms"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(640,2),line_char(640,45))). -user:metta_file_buffer(6,262000642,metta_other,['@doc','superpose-bind',['@desc',"Complement to the collapse-bind. It takes result of collapse-bind (first argument) and returns only result atoms without bindings. Primarily used with some filtering step on the collapse-bind results, i.e. collapse-bind -> -> superpose-bind."],['@params',[['@param',"Expression in form (Atom Binding)"]]],['@return',"Non-deterministic list of Atoms"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(636,0),line_char(640,46))). -user:metta_file_buffer(6,263000642,indexed(metta_comment,";; superpose-bind because `superpose` doesnt guarentee shared bindings"),'$COMMENT'(";; superpose-bind because `superpose` doesnt guarentee shared bindings",641,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(641,0),line_char(641,70))). -user:metta_file_buffer(7,263000643,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(642,1),line_char(642,2))). -user:metta_file_buffer(7,263000643,constant,'superpose-bind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(642,3),line_char(642,17))). -user:metta_file_buffer(8,263000644,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(642,19),line_char(642,21))). -user:metta_file_buffer(8,263000644,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(642,22),line_char(642,32))). -user:metta_file_buffer(8,263000644,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(642,33),line_char(642,37))). -user:metta_file_buffer(7,263000644,metta_other,[->,'Expression','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(642,18),line_char(642,38))). -user:metta_file_buffer(6,263000644,metta_typedecl,[:,'superpose-bind',[->,'Expression','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(642,0),line_char(642,39))). -user:metta_file_buffer(6,264000644,indexed(metta_comment,"; Helper Minimal Metta?"),'$COMMENT'("; Helper Minimal Metta?",644,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(644,0),line_char(644,23))). -user:metta_file_buffer(7,264000645,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(645,1),line_char(645,5))). -user:metta_file_buffer(7,264000645,constant,metta,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(645,6),line_char(645,11))). -user:metta_file_buffer(8,264000646,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(646,3),line_char(646,8))). -user:metta_file_buffer(8,264000646,string,"Run MeTTa interpreter on atom.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(646,9),line_char(646,41))). -user:metta_file_buffer(7,264000646,metta_other,['@desc',"Run MeTTa interpreter on atom."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(646,2),line_char(646,42))). -user:metta_file_buffer(8,264000647,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(647,3),line_char(647,10))). -user:metta_file_buffer(10,264000649,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(648,5),line_char(648,11))). -user:metta_file_buffer(10,264000649,string,"Atom to be interpreted",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(648,12),line_char(648,36))). -user:metta_file_buffer(9,264000649,metta_other,['@param',"Atom to be interpreted"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(648,4),line_char(648,37))). -user:metta_file_buffer(10,264000650,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(649,5),line_char(649,11))). -user:metta_file_buffer(10,264000650,string,"Type of input atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(649,12),line_char(649,32))). -user:metta_file_buffer(9,264000650,metta_other,['@param',"Type of input atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(649,4),line_char(649,33))). -user:metta_file_buffer(10,264000651,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(650,5),line_char(650,11))). -user:metta_file_buffer(10,264000651,string,"Atomspace where intepretation should take place",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(650,12),line_char(650,61))). -user:metta_file_buffer(9,264000651,metta_other,['@param',"Atomspace where intepretation should take place"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(650,4),line_char(650,62))). -user:metta_file_buffer(8,264000651,array,[['@param',"Atom to be interpreted"],['@param',"Type of input atom"],['@param',"Atomspace where intepretation should take place"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(647,11),line_char(650,63))). -user:metta_file_buffer(7,264000651,metta_other,['@params',[['@param',"Atom to be interpreted"],['@param',"Type of input atom"],['@param',"Atomspace where intepretation should take place"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(647,2),line_char(650,64))). -user:metta_file_buffer(8,264000652,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(651,3),line_char(651,10))). -user:metta_file_buffer(8,264000652,string,"Result of interpretation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(651,11),line_char(651,37))). -user:metta_file_buffer(7,264000652,metta_other,['@return',"Result of interpretation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(651,2),line_char(651,38))). -user:metta_file_buffer(6,264000652,metta_other,['@doc',metta,['@desc',"Run MeTTa interpreter on atom."],['@params',[['@param',"Atom to be interpreted"],['@param',"Type of input atom"],['@param',"Atomspace where intepretation should take place"]]],['@return',"Result of interpretation"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(645,0),line_char(651,39))). -user:metta_file_buffer(7,265000653,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(652,1),line_char(652,2))). -user:metta_file_buffer(7,265000653,constant,metta,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(652,3),line_char(652,8))). -user:metta_file_buffer(8,265000654,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(652,10),line_char(652,12))). -user:metta_file_buffer(8,265000654,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(652,13),line_char(652,17))). -user:metta_file_buffer(8,265000654,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(652,18),line_char(652,22))). -user:metta_file_buffer(8,265000654,constant,'Grounded',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(652,23),line_char(652,31))). -user:metta_file_buffer(8,265000654,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(652,32),line_char(652,36))). -user:metta_file_buffer(7,265000654,metta_other,[->,'Atom','Type','Grounded','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(652,9),line_char(652,37))). -user:metta_file_buffer(6,265000654,metta_typedecl,[:,metta,[->,'Atom','Type','Grounded','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(652,0),line_char(652,38))). -user:metta_file_buffer(7,266000655,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(654,1),line_char(654,3))). -user:metta_file_buffer(7,266000655,constant,id,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(654,4),line_char(654,6))). -user:metta_file_buffer(7,266000655,constant,'MinimalMeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(654,7),line_char(654,19))). -user:metta_file_buffer(6,266000655,metta_other,[iz,id,'MinimalMeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(654,0),line_char(654,20))). -user:metta_file_buffer(7,267000656,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(655,1),line_char(655,5))). -user:metta_file_buffer(7,267000656,constant,id,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(655,6),line_char(655,8))). -user:metta_file_buffer(8,267000657,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(656,3),line_char(656,8))). -user:metta_file_buffer(8,267000657,string,"Returns its argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(656,9),line_char(656,31))). -user:metta_file_buffer(7,267000657,metta_other,['@desc',"Returns its argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(656,2),line_char(656,32))). -user:metta_file_buffer(8,267000658,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(657,3),line_char(657,10))). -user:metta_file_buffer(10,267000660,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(658,5),line_char(658,11))). -user:metta_file_buffer(10,267000660,string,"Input argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(658,12),line_char(658,28))). -user:metta_file_buffer(9,267000660,metta_other,['@param',"Input argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(658,4),line_char(658,29))). -user:metta_file_buffer(8,267000660,array,[['@param',"Input argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(657,11),line_char(658,30))). -user:metta_file_buffer(7,267000660,metta_other,['@params',[['@param',"Input argument"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(657,2),line_char(658,31))). -user:metta_file_buffer(8,267000661,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(659,3),line_char(659,10))). -user:metta_file_buffer(8,267000661,string,"Input argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(659,11),line_char(659,27))). -user:metta_file_buffer(7,267000661,metta_other,['@return',"Input argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(659,2),line_char(659,28))). -user:metta_file_buffer(6,267000661,metta_other,['@doc',id,['@desc',"Returns its argument"],['@params',[['@param',"Input argument"]]],['@return',"Input argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(655,0),line_char(659,29))). -user:metta_file_buffer(7,268000662,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(660,1),line_char(660,2))). -user:metta_file_buffer(7,268000662,constant,id,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(660,3),line_char(660,5))). -user:metta_file_buffer(8,268000663,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(660,7),line_char(660,9))). -user:metta_file_buffer(8,268000663,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(660,10),line_char(660,14))). -user:metta_file_buffer(8,268000663,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(660,15),line_char(660,19))). -user:metta_file_buffer(7,268000663,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(660,6),line_char(660,20))). -user:metta_file_buffer(6,268000663,metta_typedecl,[:,id,[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(660,0),line_char(660,21))). -user:metta_file_buffer(7,269000664,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(661,1),line_char(661,2))). -user:metta_file_buffer(8,269000665,constant,id,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(661,4),line_char(661,6))). -user:metta_file_buffer(8,269000665,variable,_127468,['_x'=_127468],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(661,7),line_char(661,9))). -user:metta_file_buffer(7,269000665,indexed(metta_other,[id,_128302]),[id,_128354],['_x'=_128354],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(661,3),line_char(661,10))). -user:metta_file_buffer(7,269000665,variable,_129286,['_x'=_129286],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(661,11),line_char(661,13))). -user:metta_file_buffer(6,269000665,indexed(metta_defun,[id,_130142]),[=,[id,_130224],_130224],['_x'=_130224],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(661,0),line_char(661,14))). -user:metta_file_buffer(7,270000666,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(663,1),line_char(663,3))). -user:metta_file_buffer(7,270000666,constant,'atom-subst',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(663,4),line_char(663,14))). -user:metta_file_buffer(7,270000666,constant,'MinimalMeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(663,15),line_char(663,27))). -user:metta_file_buffer(6,270000666,metta_other,[iz,'atom-subst','MinimalMeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(663,0),line_char(663,28))). -user:metta_file_buffer(7,271000667,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(664,1),line_char(664,5))). -user:metta_file_buffer(7,271000667,constant,'atom-subst',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(664,6),line_char(664,16))). -user:metta_file_buffer(8,271000668,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(665,3),line_char(665,8))). -user:metta_file_buffer(8,271000668,string,"Substitutes variable passed as a second argument in the third argument by the first argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(665,9),line_char(665,103))). -user:metta_file_buffer(7,271000668,metta_other,['@desc',"Substitutes variable passed as a second argument in the third argument by the first argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(665,2),line_char(665,104))). -user:metta_file_buffer(8,271000669,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(666,3),line_char(666,10))). -user:metta_file_buffer(10,271000671,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(667,5),line_char(667,11))). -user:metta_file_buffer(10,271000671,string,"Value to use for replacement",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(667,12),line_char(667,42))). -user:metta_file_buffer(9,271000671,metta_other,['@param',"Value to use for replacement"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(667,4),line_char(667,43))). -user:metta_file_buffer(10,271000672,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(668,5),line_char(668,11))). -user:metta_file_buffer(10,271000672,string,"Variable to replace",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(668,12),line_char(668,33))). -user:metta_file_buffer(9,271000672,metta_other,['@param',"Variable to replace"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(668,4),line_char(668,34))). -user:metta_file_buffer(10,271000673,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(669,5),line_char(669,11))). -user:metta_file_buffer(10,271000673,string,"Template to replace variable by the value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(669,12),line_char(669,55))). -user:metta_file_buffer(9,271000673,metta_other,['@param',"Template to replace variable by the value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(669,4),line_char(669,56))). -user:metta_file_buffer(8,271000673,array,[['@param',"Value to use for replacement"],['@param',"Variable to replace"],['@param',"Template to replace variable by the value"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(666,11),line_char(669,57))). -user:metta_file_buffer(7,271000673,metta_other,['@params',[['@param',"Value to use for replacement"],['@param',"Variable to replace"],['@param',"Template to replace variable by the value"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(666,2),line_char(669,58))). -user:metta_file_buffer(8,271000674,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(670,3),line_char(670,10))). -user:metta_file_buffer(8,271000674,string,"Template with substituted variable",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(670,11),line_char(670,47))). -user:metta_file_buffer(7,271000674,metta_other,['@return',"Template with substituted variable"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(670,2),line_char(670,48))). -user:metta_file_buffer(6,271000674,metta_other,['@doc','atom-subst',['@desc',"Substitutes variable passed as a second argument in the third argument by the first argument"],['@params',[['@param',"Value to use for replacement"],['@param',"Variable to replace"],['@param',"Template to replace variable by the value"]]],['@return',"Template with substituted variable"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(664,0),line_char(670,49))). -user:metta_file_buffer(7,272000675,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(671,1),line_char(671,2))). -user:metta_file_buffer(7,272000675,constant,'atom-subst',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(671,3),line_char(671,13))). -user:metta_file_buffer(8,272000676,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(671,15),line_char(671,17))). -user:metta_file_buffer(8,272000676,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(671,18),line_char(671,22))). -user:metta_file_buffer(8,272000676,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(671,23),line_char(671,31))). -user:metta_file_buffer(8,272000676,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(671,32),line_char(671,36))). -user:metta_file_buffer(8,272000676,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(671,37),line_char(671,41))). -user:metta_file_buffer(7,272000676,metta_other,[->,'Atom','Variable','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(671,14),line_char(671,42))). -user:metta_file_buffer(6,272000676,metta_typedecl,[:,'atom-subst',[->,'Atom','Variable','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(671,0),line_char(671,43))). -user:metta_file_buffer(6,273000676,indexed(metta_comment,";; Maybe Implement from Interpreter? But our transpiler should brilliantt enbought to make this awesome prolog code instead"),'$COMMENT'(";; Maybe Implement from Interpreter? But our transpiler should brilliantt enbought to make this awesome prolog code instead",672,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(672,0),line_char(672,123))). -user:metta_file_buffer(7,273000677,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(673,1),line_char(673,2))). -user:metta_file_buffer(8,273000678,constant,'atom-subst',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(673,4),line_char(673,14))). -user:metta_file_buffer(8,273000678,variable,_128148,['_atom'=_128148],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(673,15),line_char(673,20))). -user:metta_file_buffer(8,273000678,variable,_129416,['_var'=_129416],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(673,21),line_char(673,25))). -user:metta_file_buffer(8,273000678,variable,_130724,['_templ'=_130724],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(673,26),line_char(673,32))). -user:metta_file_buffer(7,273000678,indexed(metta_other,['atom-subst',_131570,_131592,_131614]),['atom-subst',_131666,_131672,_131678],['_templ'=_131678,'_var'=_131672,'_atom'=_131666],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(673,3),line_char(673,33))). -user:metta_file_buffer(8,273000679,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,3),line_char(674,11))). -user:metta_file_buffer(9,273000680,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,13),line_char(674,18))). -user:metta_file_buffer(10,273000681,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,20),line_char(674,24))). -user:metta_file_buffer(11,273000682,constant,id,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,26),line_char(674,28))). -user:metta_file_buffer(11,273000682,variable,_135892,['_atom'=_135892],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,29),line_char(674,34))). -user:metta_file_buffer(10,273000682,indexed(metta_other,[id,_136726]),[id,_136778],['_atom'=_136778],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,25),line_char(674,35))). -user:metta_file_buffer(9,273000682,indexed(metta_other,[eval,[id,_137316]]),[eval,[id,_137380]],['_atom'=_137380],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,19),line_char(674,36))). -user:metta_file_buffer(9,273000682,variable,_138336,['_var'=_138336],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,37),line_char(674,41))). -user:metta_file_buffer(10,273000683,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,43),line_char(674,49))). -user:metta_file_buffer(10,273000683,variable,_140458,['_templ'=_140458],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,50),line_char(674,56))). -user:metta_file_buffer(9,273000683,indexed(metta_other,[return,_141292]),[return,_141344],['_templ'=_141344],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,42),line_char(674,57))). -user:metta_file_buffer(8,273000683,indexed(metta_other,[chain,[eval,[id,_141910]],_141932,[return,_141970]]),[chain,[eval,[id,_142046]],_142052,[return,_142070]],['_templ'=_142070,'_var'=_142052,'_atom'=_142046],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,12),line_char(674,58))). -user:metta_file_buffer(7,273000683,indexed(metta_other,[function,[chain,[eval,[id,_142664]],_142686,[return,_142724]]]),[function,[chain,[eval,[id,_142812]],_142818,[return,_142836]]],['_templ'=_142836,'_var'=_142818,'_atom'=_142812],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(674,2),line_char(674,59))). -user:metta_file_buffer(6,273000683,indexed(metta_defun,['atom-subst',_143406,_143428,_143450]),[=,['atom-subst',_143648,_143654,_143660],[function,[chain,[eval,[id,_143648]],_143654,[return,_143660]]]],['_templ'=_143660,'_var'=_143654,'_atom'=_143648],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(673,0),line_char(674,61))). -user:metta_file_buffer(7,274000684,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(676,1),line_char(676,3))). -user:metta_file_buffer(7,274000684,constant,'if-decons-expr',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(676,4),line_char(676,18))). -user:metta_file_buffer(7,274000684,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(676,19),line_char(676,37))). -user:metta_file_buffer(6,274000684,metta_other,[iz,'if-decons-expr','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(676,0),line_char(676,38))). -user:metta_file_buffer(7,275000685,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(677,1),line_char(677,5))). -user:metta_file_buffer(7,275000685,constant,'if-decons-expr',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(677,6),line_char(677,20))). -user:metta_file_buffer(8,275000686,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(678,3),line_char(678,8))). -user:metta_file_buffer(8,275000686,string,"Checks if first argument is non empty expression. If so gets tail and head from the first argument and returns forth argument using head and tail values. Returns fifth argument otherwise.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(678,9),line_char(678,198))). -user:metta_file_buffer(7,275000686,metta_other,['@desc',"Checks if first argument is non empty expression. If so gets tail and head from the first argument and returns forth argument using head and tail values. Returns fifth argument otherwise."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(678,2),line_char(678,199))). -user:metta_file_buffer(8,275000687,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(679,3),line_char(679,10))). -user:metta_file_buffer(10,275000689,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(680,5),line_char(680,11))). -user:metta_file_buffer(10,275000689,string,"Expression to be deconstructed",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(680,12),line_char(680,44))). -user:metta_file_buffer(9,275000689,metta_other,['@param',"Expression to be deconstructed"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(680,4),line_char(680,45))). -user:metta_file_buffer(10,275000690,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(681,5),line_char(681,11))). -user:metta_file_buffer(10,275000690,string,"Head variable",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(681,12),line_char(681,27))). -user:metta_file_buffer(9,275000690,metta_other,['@param',"Head variable"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(681,4),line_char(681,28))). -user:metta_file_buffer(10,275000691,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(682,5),line_char(682,11))). -user:metta_file_buffer(10,275000691,string,"Tail variable",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(682,12),line_char(682,27))). -user:metta_file_buffer(9,275000691,metta_other,['@param',"Tail variable"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(682,4),line_char(682,28))). -user:metta_file_buffer(10,275000692,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(683,5),line_char(683,11))). -user:metta_file_buffer(10,275000692,string,"Template to return if first argument is a non-empty expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(683,12),line_char(683,76))). -user:metta_file_buffer(9,275000692,metta_other,['@param',"Template to return if first argument is a non-empty expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(683,4),line_char(683,77))). -user:metta_file_buffer(10,275000693,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(684,5),line_char(684,11))). -user:metta_file_buffer(10,275000693,string,"Default value to return otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(684,12),line_char(684,47))). -user:metta_file_buffer(9,275000693,metta_other,['@param',"Default value to return otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(684,4),line_char(684,48))). -user:metta_file_buffer(8,275000693,array,[['@param',"Expression to be deconstructed"],['@param',"Head variable"],['@param',"Tail variable"],['@param',"Template to return if first argument is a non-empty expression"],['@param',"Default value to return otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(679,11),line_char(684,49))). -user:metta_file_buffer(7,275000693,metta_other,['@params',[['@param',"Expression to be deconstructed"],['@param',"Head variable"],['@param',"Tail variable"],['@param',"Template to return if first argument is a non-empty expression"],['@param',"Default value to return otherwise"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(679,2),line_char(684,50))). -user:metta_file_buffer(8,275000694,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(685,3),line_char(685,10))). -user:metta_file_buffer(8,275000694,string,"Either template with head and tail replaced by values or default value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(685,11),line_char(685,83))). -user:metta_file_buffer(7,275000694,metta_other,['@return',"Either template with head and tail replaced by values or default value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(685,2),line_char(685,84))). -user:metta_file_buffer(6,275000694,metta_other,['@doc','if-decons-expr',['@desc',"Checks if first argument is non empty expression. If so gets tail and head from the first argument and returns forth argument using head and tail values. Returns fifth argument otherwise."],['@params',[['@param',"Expression to be deconstructed"],['@param',"Head variable"],['@param',"Tail variable"],['@param',"Template to return if first argument is a non-empty expression"],['@param',"Default value to return otherwise"]]],['@return',"Either template with head and tail replaced by values or default value"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(677,0),line_char(685,85))). -user:metta_file_buffer(7,276000695,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(686,1),line_char(686,2))). -user:metta_file_buffer(7,276000695,constant,'if-decons-expr',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(686,3),line_char(686,17))). -user:metta_file_buffer(8,276000696,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(686,19),line_char(686,21))). -user:metta_file_buffer(8,276000696,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(686,22),line_char(686,32))). -user:metta_file_buffer(8,276000696,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(686,33),line_char(686,41))). -user:metta_file_buffer(8,276000696,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(686,42),line_char(686,50))). -user:metta_file_buffer(8,276000696,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(686,51),line_char(686,55))). -user:metta_file_buffer(8,276000696,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(686,56),line_char(686,60))). -user:metta_file_buffer(8,276000696,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(686,61),line_char(686,65))). -user:metta_file_buffer(7,276000696,metta_other,[->,'Expression','Variable','Variable','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(686,18),line_char(686,66))). -user:metta_file_buffer(6,276000696,metta_typedecl,[:,'if-decons-expr',[->,'Expression','Variable','Variable','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(686,0),line_char(686,67))). -user:metta_file_buffer(6,277000696,indexed(metta_comment,";; Maybe Implement from Interpreter? But our transpiler should brilliantt enbought to make this awesome prolog code instead"),'$COMMENT'(";; Maybe Implement from Interpreter? But our transpiler should brilliantt enbought to make this awesome prolog code instead",687,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(687,0),line_char(687,123))). -user:metta_file_buffer(7,277000697,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(688,1),line_char(688,2))). -user:metta_file_buffer(8,277000698,constant,'if-decons-expr',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(688,4),line_char(688,18))). -user:metta_file_buffer(8,277000698,variable,_128188,['_atom'=_128188],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(688,19),line_char(688,24))). -user:metta_file_buffer(8,277000698,variable,_129472,['_head'=_129472],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(688,25),line_char(688,30))). -user:metta_file_buffer(8,277000698,variable,_130756,['_tail'=_130756],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(688,31),line_char(688,36))). -user:metta_file_buffer(8,277000698,variable,_132040,['_then'=_132040],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(688,37),line_char(688,42))). -user:metta_file_buffer(8,277000698,variable,_133332,['_else'=_133332],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(688,43),line_char(688,48))). -user:metta_file_buffer(7,277000698,indexed(metta_other,['if-decons-expr',_134190,_134212,_134234,_134256,_134278]),['if-decons-expr',_134330,_134336,_134342,_134348,_134354],['_else'=_134354,'_then'=_134348,'_tail'=_134342,'_head'=_134336,'_atom'=_134330],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(688,3),line_char(688,49))). -user:metta_file_buffer(8,277000699,constant,'if-decons',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(689,3),line_char(689,12))). -user:metta_file_buffer(8,277000699,variable,_136154,['_atom'=_136154],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(689,13),line_char(689,18))). -user:metta_file_buffer(8,277000699,variable,_137438,['_head'=_137438],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(689,19),line_char(689,24))). -user:metta_file_buffer(8,277000699,variable,_138722,['_tail'=_138722],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(689,25),line_char(689,30))). -user:metta_file_buffer(8,277000699,variable,_140006,['_then'=_140006],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(689,31),line_char(689,36))). -user:metta_file_buffer(8,277000699,variable,_141298,['_else'=_141298],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(689,37),line_char(689,42))). -user:metta_file_buffer(7,277000699,indexed(metta_other,['if-decons',_142156,_142178,_142200,_142222,_142244]),['if-decons',_142296,_142302,_142308,_142314,_142320],['_else'=_142320,'_then'=_142314,'_tail'=_142308,'_head'=_142302,'_atom'=_142296],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(689,2),line_char(689,43))). -user:metta_file_buffer(6,277000699,indexed(metta_defun,['if-decons-expr',_142912,_142934,_142956,_142978,_143000]),[=,['if-decons-expr',_143170,_143176,_143182,_143188,_143194],['if-decons',_143170,_143176,_143182,_143188,_143194]],['_else'=_143194,'_then'=_143188,'_tail'=_143182,'_head'=_143176,'_atom'=_143170],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(688,0),line_char(689,44))). -user:metta_file_buffer(7,278000700,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(690,1),line_char(690,2))). -user:metta_file_buffer(7,278000700,constant,'if-decons',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(690,3),line_char(690,12))). -user:metta_file_buffer(8,278000701,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(690,14),line_char(690,16))). -user:metta_file_buffer(8,278000701,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(690,17),line_char(690,27))). -user:metta_file_buffer(8,278000701,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(690,28),line_char(690,36))). -user:metta_file_buffer(8,278000701,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(690,37),line_char(690,45))). -user:metta_file_buffer(8,278000701,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(690,46),line_char(690,50))). -user:metta_file_buffer(8,278000701,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(690,51),line_char(690,55))). -user:metta_file_buffer(8,278000701,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(690,56),line_char(690,60))). -user:metta_file_buffer(7,278000701,metta_other,[->,'Expression','Variable','Variable','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(690,13),line_char(690,61))). -user:metta_file_buffer(6,278000701,metta_typedecl,[:,'if-decons',[->,'Expression','Variable','Variable','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(690,0),line_char(690,62))). -user:metta_file_buffer(7,279000702,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(691,1),line_char(691,5))). -user:metta_file_buffer(8,279000703,constant,'if-decons-expr',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(691,7),line_char(691,21))). -user:metta_file_buffer(8,279000703,variable,_127632,['_atom'=_127632],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(691,22),line_char(691,27))). -user:metta_file_buffer(8,279000703,variable,_128916,['_head'=_128916],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(691,28),line_char(691,33))). -user:metta_file_buffer(8,279000703,variable,_130200,['_tail'=_130200],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(691,34),line_char(691,39))). -user:metta_file_buffer(8,279000703,variable,_131484,['_then'=_131484],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(691,40),line_char(691,45))). -user:metta_file_buffer(8,279000703,variable,_132776,['_else'=_132776],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(691,46),line_char(691,51))). -user:metta_file_buffer(7,279000703,indexed(metta_other,['if-decons-expr',_133634,_133656,_133678,_133700,_133722]),['if-decons-expr',_133774,_133780,_133786,_133792,_133798],['_else'=_133798,'_then'=_133792,'_tail'=_133786,'_head'=_133780,'_atom'=_133774],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(691,6),line_char(691,52))). -user:metta_file_buffer(8,279000704,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(692,3),line_char(692,11))). -user:metta_file_buffer(9,279000705,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(692,13),line_char(692,17))). -user:metta_file_buffer(10,279000706,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(692,19),line_char(692,27))). -user:metta_file_buffer(10,279000706,variable,_137216,['_atom'=_137216],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(692,28),line_char(692,33))). -user:metta_file_buffer(10,279000707,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(692,34),line_char(692,36))). -user:metta_file_buffer(11,279000708,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(693,5),line_char(693,11))). -user:metta_file_buffer(11,279000708,variable,_139978,['_else'=_139978],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(693,12),line_char(693,17))). -user:metta_file_buffer(10,279000708,indexed(metta_other,[return,_140812]),[return,_140864],['_else'=_140864],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(693,4),line_char(693,18))). -user:metta_file_buffer(11,279000709,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(694,5),line_char(694,10))). -user:metta_file_buffer(12,279000710,constant,'decons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(694,12),line_char(694,23))). -user:metta_file_buffer(12,279000710,variable,_143452,['_atom'=_143452],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(694,24),line_char(694,29))). -user:metta_file_buffer(11,279000710,indexed(metta_other,['decons-atom',_144286]),['decons-atom',_144338],['_atom'=_144338],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(694,11),line_char(694,30))). -user:metta_file_buffer(11,279000710,variable,_145310,['_list'=_145310],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(694,31),line_char(694,36))). -user:metta_file_buffer(12,279000711,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(695,7),line_char(695,15))). -user:metta_file_buffer(12,279000711,variable,_147372,['_list'=_147372],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(695,16),line_char(695,21))). -user:metta_file_buffer(13,279000712,variable,_148794,['_head'=_148794],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(695,23),line_char(695,28))). -user:metta_file_buffer(13,279000712,variable,_150086,['_tail'=_150086],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(695,29),line_char(695,34))). -user:metta_file_buffer(12,279000712,indexed(metta_other,[_150912,_150934]),[_150980,_150986],['_tail'=_150986,'_head'=_150980],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(695,22),line_char(695,35))). -user:metta_file_buffer(13,279000713,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(695,37),line_char(695,43))). -user:metta_file_buffer(13,279000713,variable,_152792,['_then'=_152792],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(695,44),line_char(695,49))). -user:metta_file_buffer(12,279000713,indexed(metta_other,[return,_153626]),[return,_153678],['_then'=_153678],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(695,36),line_char(695,50))). -user:metta_file_buffer(13,279000714,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(695,52),line_char(695,58))). -user:metta_file_buffer(13,279000714,variable,_155472,['_else'=_155472],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(695,59),line_char(695,64))). -user:metta_file_buffer(12,279000714,indexed(metta_other,[return,_156306]),[return,_156358],['_else'=_156358],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(695,51),line_char(695,65))). -user:metta_file_buffer(11,279000714,indexed(metta_other,['if-unify',_156898,[_156928,_156950],[return,_156988],[return,_157026]]),['if-unify',_157078,[_157090,_157096],[return,_157114],[return,_157132]],['_else'=_157132,'_then'=_157114,'_tail'=_157096,'_head'=_157090,'_list'=_157078],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(695,6),line_char(695,66))). -user:metta_file_buffer(10,279000714,indexed(metta_other,[chain,['decons-atom',_157732],_157754,['if-unify',_157754,[_157818,_157840],[return,_157878],[return,_157916]]]),[chain,['decons-atom',_157980],_157986,['if-unify',_157986,[_158016,_158022],[return,_158040],[return,_158058]]],['_else'=_158058,'_then'=_158040,'_tail'=_158022,'_head'=_158016,'_list'=_157986,'_atom'=_157980],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(694,4),line_char(695,68))). -user:metta_file_buffer(9,279000714,indexed(metta_other,['if-equal',_158658,[],[return,_158704],[chain,['decons-atom',_158658],_158776,['if-unify',_158776,[_158840,_158862],[return,_158900],[return,_158704]]]]),['if-equal',_158986,[],[return,_159010],[chain,['decons-atom',_158986],_159046,['if-unify',_159046,[_159076,_159082],[return,_159100],[return,_159010]]]],['_then'=_159100,'_tail'=_159082,'_head'=_159076,'_list'=_159046,'_else'=_159010,'_atom'=_158986],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(692,18),line_char(695,69))). -user:metta_file_buffer(8,279000714,indexed(metta_other,[eval,['if-equal',_159716,[],[return,_159762],[chain,['decons-atom',_159716],_159834,['if-unify',_159834,[_159898,_159920],[return,_159958],[return,_159762]]]]]),[eval,['if-equal',_160056,[],[return,_160080],[chain,['decons-atom',_160056],_160116,['if-unify',_160116,[_160146,_160152],[return,_160170],[return,_160080]]]]],['_then'=_160170,'_tail'=_160152,'_head'=_160146,'_list'=_160116,'_else'=_160080,'_atom'=_160056],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(692,12),line_char(695,70))). -user:metta_file_buffer(7,279000714,indexed(metta_other,[function,[eval,['if-equal',_160802,[],[return,_160848],[chain,['decons-atom',_160802],_160920,['if-unify',_160920,[_160984,_161006],[return,_161044],[return,_160848]]]]]]),[function,[eval,['if-equal',_161154,[],[return,_161178],[chain,['decons-atom',_161154],_161214,['if-unify',_161214,[_161244,_161250],[return,_161268],[return,_161178]]]]]],['_then'=_161268,'_tail'=_161250,'_head'=_161244,'_list'=_161214,'_else'=_161178,'_atom'=_161154],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(692,2),line_char(695,71))). -user:metta_file_buffer(6,279000714,indexed(metta_other,['ALT=',['if-decons-expr',_161890,_161912,_161934,_161956,_161978],[function,[eval,['if-equal',_161890,[],[return,_161978],[chain,['decons-atom',_161890],_162158,['if-unify',_162158,[_161912,_161934],[return,_161956],[return,_161978]]]]]]]),['ALT=',['if-decons-expr',_162368,_162374,_162380,_162386,_162392],[function,[eval,['if-equal',_162368,[],[return,_162392],[chain,['decons-atom',_162368],_162494,['if-unify',_162494,[_162374,_162380],[return,_162386],[return,_162392]]]]]]],['_list'=_162494,'_else'=_162392,'_then'=_162386,'_tail'=_162380,'_head'=_162374,'_atom'=_162368],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(691,0),line_char(695,72))). -user:metta_file_buffer(7,280000715,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(697,1),line_char(697,3))). -user:metta_file_buffer(7,280000715,constant,'if-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(697,4),line_char(697,12))). -user:metta_file_buffer(7,280000715,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(697,13),line_char(697,31))). -user:metta_file_buffer(6,280000715,metta_other,[iz,'if-error','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(697,0),line_char(697,32))). -user:metta_file_buffer(7,281000716,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(698,1),line_char(698,5))). -user:metta_file_buffer(7,281000716,constant,'if-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(698,6),line_char(698,14))). -user:metta_file_buffer(8,281000717,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(699,3),line_char(699,8))). -user:metta_file_buffer(8,281000717,string,"Checks if first argument is an error atom. Returns second argument if so or third argument otherwise.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(699,9),line_char(699,112))). -user:metta_file_buffer(7,281000717,metta_other,['@desc',"Checks if first argument is an error atom. Returns second argument if so or third argument otherwise."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(699,2),line_char(699,113))). -user:metta_file_buffer(8,281000718,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(700,3),line_char(700,10))). -user:metta_file_buffer(10,281000720,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(701,5),line_char(701,11))). -user:metta_file_buffer(10,281000720,string,"Atom to be checked for the error",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(701,12),line_char(701,46))). -user:metta_file_buffer(9,281000720,metta_other,['@param',"Atom to be checked for the error"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(701,4),line_char(701,47))). -user:metta_file_buffer(10,281000721,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(702,5),line_char(702,11))). -user:metta_file_buffer(10,281000721,string,"Value to return if first argument is an error",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(702,12),line_char(702,59))). -user:metta_file_buffer(9,281000721,metta_other,['@param',"Value to return if first argument is an error"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(702,4),line_char(702,60))). -user:metta_file_buffer(10,281000722,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(703,5),line_char(703,11))). -user:metta_file_buffer(10,281000722,string,"Value to return otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(703,12),line_char(703,39))). -user:metta_file_buffer(9,281000722,metta_other,['@param',"Value to return otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(703,4),line_char(703,40))). -user:metta_file_buffer(8,281000722,array,[['@param',"Atom to be checked for the error"],['@param',"Value to return if first argument is an error"],['@param',"Value to return otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(700,11),line_char(703,41))). -user:metta_file_buffer(7,281000722,metta_other,['@params',[['@param',"Atom to be checked for the error"],['@param',"Value to return if first argument is an error"],['@param',"Value to return otherwise"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(700,2),line_char(703,42))). -user:metta_file_buffer(8,281000723,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(704,3),line_char(704,10))). -user:metta_file_buffer(8,281000723,string,"Second or third argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(704,11),line_char(704,37))). -user:metta_file_buffer(7,281000723,metta_other,['@return',"Second or third argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(704,2),line_char(704,38))). -user:metta_file_buffer(6,281000723,metta_other,['@doc','if-error',['@desc',"Checks if first argument is an error atom. Returns second argument if so or third argument otherwise."],['@params',[['@param',"Atom to be checked for the error"],['@param',"Value to return if first argument is an error"],['@param',"Value to return otherwise"]]],['@return',"Second or third argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(698,0),line_char(704,39))). -user:metta_file_buffer(7,282000724,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(705,1),line_char(705,2))). -user:metta_file_buffer(7,282000724,constant,'if-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(705,3),line_char(705,11))). -user:metta_file_buffer(8,282000725,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(705,13),line_char(705,15))). -user:metta_file_buffer(8,282000725,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(705,16),line_char(705,20))). -user:metta_file_buffer(8,282000725,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(705,21),line_char(705,25))). -user:metta_file_buffer(8,282000725,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(705,26),line_char(705,30))). -user:metta_file_buffer(8,282000725,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(705,31),line_char(705,35))). -user:metta_file_buffer(7,282000725,metta_other,[->,'Atom','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(705,12),line_char(705,36))). -user:metta_file_buffer(6,282000725,metta_typedecl,[:,'if-error',[->,'Atom','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(705,0),line_char(705,37))). -user:metta_file_buffer(6,283000725,indexed(metta_comment,";; Maybe Implement from Interpreter? But our transpiler should brilliantt enbought to make this awesome prolog code instead"),'$COMMENT'(";; Maybe Implement from Interpreter? But our transpiler should brilliantt enbought to make this awesome prolog code instead",706,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(706,0),line_char(706,123))). -user:metta_file_buffer(7,283000726,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(707,1),line_char(707,2))). -user:metta_file_buffer(8,283000727,constant,'if-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(707,4),line_char(707,12))). -user:metta_file_buffer(8,283000727,variable,_128612,['_atom'=_128612],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(707,13),line_char(707,18))). -user:metta_file_buffer(8,283000727,variable,_129896,['_then'=_129896],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(707,19),line_char(707,24))). -user:metta_file_buffer(8,283000727,variable,_131188,['_else'=_131188],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(707,25),line_char(707,30))). -user:metta_file_buffer(7,283000727,indexed(metta_other,['if-error',_132034,_132056,_132078]),['if-error',_132130,_132136,_132142],['_else'=_132142,'_then'=_132136,'_atom'=_132130],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(707,3),line_char(707,31))). -user:metta_file_buffer(8,283000728,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(708,3),line_char(708,11))). -user:metta_file_buffer(9,283000729,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(708,13),line_char(708,18))). -user:metta_file_buffer(10,283000730,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(708,20),line_char(708,24))). -user:metta_file_buffer(11,283000731,constant,'get-metatype',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(708,26),line_char(708,38))). -user:metta_file_buffer(11,283000731,variable,_136388,['_atom'=_136388],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(708,39),line_char(708,44))). -user:metta_file_buffer(10,283000731,indexed(metta_other,['get-metatype',_137222]),['get-metatype',_137274],['_atom'=_137274],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(708,25),line_char(708,45))). -user:metta_file_buffer(9,283000731,indexed(metta_other,[eval,['get-metatype',_137812]]),[eval,['get-metatype',_137876]],['_atom'=_137876],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(708,19),line_char(708,46))). -user:metta_file_buffer(9,283000731,variable,_138848,['_meta'=_138848],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(708,47),line_char(708,52))). -user:metta_file_buffer(10,283000732,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(709,5),line_char(709,9))). -user:metta_file_buffer(11,283000733,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(709,11),line_char(709,19))). -user:metta_file_buffer(11,283000733,variable,_141700,['_meta'=_141700],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(709,20),line_char(709,25))). -user:metta_file_buffer(11,283000733,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(709,26),line_char(709,36))). -user:metta_file_buffer(12,283000734,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(710,7),line_char(710,11))). -user:metta_file_buffer(13,283000735,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(710,13),line_char(710,21))). -user:metta_file_buffer(13,283000735,variable,_145204,['_atom'=_145204],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(710,22),line_char(710,27))). -user:metta_file_buffer(13,283000736,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(710,28),line_char(710,30))). -user:metta_file_buffer(14,283000737,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(711,9),line_char(711,15))). -user:metta_file_buffer(14,283000737,variable,_147974,['_else'=_147974],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(711,16),line_char(711,21))). -user:metta_file_buffer(13,283000737,indexed(metta_other,[return,_148808]),[return,_148860],['_else'=_148860],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(711,8),line_char(711,22))). -user:metta_file_buffer(14,283000738,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(712,9),line_char(712,14))). -user:metta_file_buffer(15,283000739,constant,'decons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(712,16),line_char(712,27))). -user:metta_file_buffer(15,283000739,variable,_151456,['_atom'=_151456],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(712,28),line_char(712,33))). -user:metta_file_buffer(14,283000739,indexed(metta_other,['decons-atom',_152290]),['decons-atom',_152342],['_atom'=_152342],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(712,15),line_char(712,34))). -user:metta_file_buffer(14,283000739,variable,_153314,['_list'=_153314],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(712,35),line_char(712,40))). -user:metta_file_buffer(15,283000740,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(713,11),line_char(713,19))). -user:metta_file_buffer(15,283000740,variable,_155384,['_list'=_155384],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(713,20),line_char(713,25))). -user:metta_file_buffer(16,283000741,variable,_156806,['_head'=_156806],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(713,27),line_char(713,32))). -user:metta_file_buffer(16,283000741,variable,_158098,['_tail'=_158098],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(713,33),line_char(713,38))). -user:metta_file_buffer(15,283000741,indexed(metta_other,[_158924,_158946]),[_158992,_158998],['_tail'=_158998,'_head'=_158992],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(713,26),line_char(713,39))). -user:metta_file_buffer(16,283000742,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(714,13),line_char(714,17))). -user:metta_file_buffer(17,283000743,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(714,19),line_char(714,27))). -user:metta_file_buffer(17,283000743,variable,_161566,['_head'=_161566],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(714,28),line_char(714,33))). -user:metta_file_buffer(17,283000743,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(714,34),line_char(714,39))). -user:metta_file_buffer(18,283000744,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(714,41),line_char(714,47))). -user:metta_file_buffer(18,283000744,variable,_164270,['_then'=_164270],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(714,48),line_char(714,53))). -user:metta_file_buffer(17,283000744,indexed(metta_other,[return,_165104]),[return,_165156],['_then'=_165156],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(714,40),line_char(714,54))). -user:metta_file_buffer(18,283000745,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(714,56),line_char(714,62))). -user:metta_file_buffer(18,283000745,variable,_166950,['_else'=_166950],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(714,63),line_char(714,68))). -user:metta_file_buffer(17,283000745,indexed(metta_other,[return,_167784]),[return,_167836],['_else'=_167836],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(714,55),line_char(714,69))). -user:metta_file_buffer(16,283000745,indexed(metta_other,['if-equal',_168376,'Error',[return,_168422],[return,_168460]]),['if-equal',_168512,'Error',[return,_168536],[return,_168554]],['_else'=_168554,'_then'=_168536,'_head'=_168512],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(714,18),line_char(714,70))). -user:metta_file_buffer(15,283000745,indexed(metta_other,[eval,['if-equal',_169116,'Error',[return,_169162],[return,_169200]]]),[eval,['if-equal',_169264,'Error',[return,_169288],[return,_169306]]],['_else'=_169306,'_then'=_169288,'_head'=_169264],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(714,12),line_char(714,71))). -user:metta_file_buffer(16,283000746,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(715,13),line_char(715,19))). -user:metta_file_buffer(16,283000746,variable,_171148,['_else'=_171148],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(715,20),line_char(715,25))). -user:metta_file_buffer(15,283000746,indexed(metta_other,[return,_171982]),[return,_172034],['_else'=_172034],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(715,12),line_char(715,26))). -user:metta_file_buffer(14,283000746,indexed(metta_other,['if-unify',_172576,[_172606,_172628],[eval,['if-equal',_172606,'Error',[return,_172724],[return,_172762]]],[return,_172762]]),['if-unify',_172848,[_172860,_172866],[eval,['if-equal',_172860,'Error',[return,_172920],[return,_172938]]],[return,_172938]],['_else'=_172938,'_then'=_172920,'_tail'=_172866,'_head'=_172860,'_list'=_172848],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(713,10),line_char(715,28))). -user:metta_file_buffer(13,283000746,indexed(metta_other,[chain,['decons-atom',_173554],_173576,['if-unify',_173576,[_173640,_173662],[eval,['if-equal',_173640,'Error',[return,_173758],[return,_173796]]],[return,_173796]]]),[chain,['decons-atom',_173894],_173900,['if-unify',_173900,[_173930,_173936],[eval,['if-equal',_173930,'Error',[return,_173990],[return,_174008]]],[return,_174008]]],['_else'=_174008,'_then'=_173990,'_tail'=_173936,'_head'=_173930,'_list'=_173900,'_atom'=_173894],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(712,8),line_char(715,29))). -user:metta_file_buffer(12,283000746,indexed(metta_other,['if-equal',_174626,[],[return,_174672],[chain,['decons-atom',_174626],_174744,['if-unify',_174744,[_174808,_174830],[eval,['if-equal',_174808,'Error',[return,_174926],[return,_174672]]],[return,_174672]]]]),['if-equal',_175046,[],[return,_175070],[chain,['decons-atom',_175046],_175106,['if-unify',_175106,[_175136,_175142],[eval,['if-equal',_175136,'Error',[return,_175196],[return,_175070]]],[return,_175070]]]],['_then'=_175196,'_tail'=_175142,'_head'=_175136,'_list'=_175106,'_else'=_175070,'_atom'=_175046],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(710,12),line_char(715,30))). -user:metta_file_buffer(11,283000746,indexed(metta_other,[eval,['if-equal',_175830,[],[return,_175876],[chain,['decons-atom',_175830],_175948,['if-unify',_175948,[_176012,_176034],[eval,['if-equal',_176012,'Error',[return,_176130],[return,_175876]]],[return,_175876]]]]]),[eval,['if-equal',_176262,[],[return,_176286],[chain,['decons-atom',_176262],_176322,['if-unify',_176322,[_176352,_176358],[eval,['if-equal',_176352,'Error',[return,_176412],[return,_176286]]],[return,_176286]]]]],['_then'=_176412,'_tail'=_176358,'_head'=_176352,'_list'=_176322,'_else'=_176286,'_atom'=_176262],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(710,6),line_char(715,31))). -user:metta_file_buffer(12,283000747,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(716,7),line_char(716,13))). -user:metta_file_buffer(12,283000747,variable,_178314,['_else'=_178314],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(716,14),line_char(716,19))). -user:metta_file_buffer(11,283000747,indexed(metta_other,[return,_179148]),[return,_179200],['_else'=_179200],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(716,6),line_char(716,20))). -user:metta_file_buffer(10,283000747,indexed(metta_other,['if-equal',_179742,'Expression',[eval,['if-equal',_179804,[],[return,_179850],[chain,['decons-atom',_179804],_179922,['if-unify',_179922,[_179986,_180008],[eval,['if-equal',_179986,'Error',[return,_180104],[return,_179850]]],[return,_179850]]]]],[return,_179850]]),['if-equal',_180258,'Expression',[eval,['if-equal',_180294,[],[return,_180318],[chain,['decons-atom',_180294],_180354,['if-unify',_180354,[_180384,_180390],[eval,['if-equal',_180384,'Error',[return,_180444],[return,_180318]]],[return,_180318]]]]],[return,_180318]],['_then'=_180444,'_tail'=_180390,'_head'=_180384,'_list'=_180354,'_else'=_180318,'_atom'=_180294,'_meta'=_180258],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(709,10),line_char(716,22))). -user:metta_file_buffer(9,283000747,indexed(metta_other,[eval,['if-equal',_181108,'Expression',[eval,['if-equal',_181170,[],[return,_181216],[chain,['decons-atom',_181170],_181288,['if-unify',_181288,[_181352,_181374],[eval,['if-equal',_181352,'Error',[return,_181470],[return,_181216]]],[return,_181216]]]]],[return,_181216]]]),[eval,['if-equal',_181636,'Expression',[eval,['if-equal',_181672,[],[return,_181696],[chain,['decons-atom',_181672],_181732,['if-unify',_181732,[_181762,_181768],[eval,['if-equal',_181762,'Error',[return,_181822],[return,_181696]]],[return,_181696]]]]],[return,_181696]]],['_then'=_181822,'_tail'=_181768,'_head'=_181762,'_list'=_181732,'_else'=_181696,'_atom'=_181672,'_meta'=_181636],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(709,4),line_char(716,23))). -user:metta_file_buffer(8,283000747,indexed(metta_other,[chain,[eval,['get-metatype',_182514]],_182536,[eval,['if-equal',_182536,'Expression',[eval,['if-equal',_182514,[],[return,_182690],[chain,['decons-atom',_182514],_182762,['if-unify',_182762,[_182826,_182848],[eval,['if-equal',_182826,'Error',[return,_182944],[return,_182690]]],[return,_182690]]]]],[return,_182690]]]]),[chain,[eval,['get-metatype',_183122]],_183128,[eval,['if-equal',_183128,'Expression',[eval,['if-equal',_183122,[],[return,_183218],[chain,['decons-atom',_183122],_183254,['if-unify',_183254,[_183284,_183290],[eval,['if-equal',_183284,'Error',[return,_183344],[return,_183218]]],[return,_183218]]]]],[return,_183218]]]],['_then'=_183344,'_tail'=_183290,'_head'=_183284,'_list'=_183254,'_else'=_183218,'_meta'=_183128,'_atom'=_183122],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(708,12),line_char(716,24))). -user:metta_file_buffer(7,283000747,indexed(metta_other,[function,[chain,[eval,['get-metatype',_184040]],_184062,[eval,['if-equal',_184062,'Expression',[eval,['if-equal',_184040,[],[return,_184216],[chain,['decons-atom',_184040],_184288,['if-unify',_184288,[_184352,_184374],[eval,['if-equal',_184352,'Error',[return,_184470],[return,_184216]]],[return,_184216]]]]],[return,_184216]]]]]),[function,[chain,[eval,['get-metatype',_184660]],_184666,[eval,['if-equal',_184666,'Expression',[eval,['if-equal',_184660,[],[return,_184756],[chain,['decons-atom',_184660],_184792,['if-unify',_184792,[_184822,_184828],[eval,['if-equal',_184822,'Error',[return,_184882],[return,_184756]]],[return,_184756]]]]],[return,_184756]]]]],['_then'=_184882,'_tail'=_184828,'_head'=_184822,'_list'=_184792,'_else'=_184756,'_meta'=_184666,'_atom'=_184660],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(708,2),line_char(716,25))). -user:metta_file_buffer(6,283000747,indexed(metta_defun,['if-error',_185552,_185574,_185596]),[=,['if-error',_186266,_186272,_186278],[function,[chain,[eval,['get-metatype',_186266]],_186338,[eval,['if-equal',_186338,'Expression',[eval,['if-equal',_186266,[],[return,_186278],[chain,['decons-atom',_186266],_186464,['if-unify',_186464,[_186494,_186500],[eval,['if-equal',_186494,'Error',[return,_186272],[return,_186278]]],[return,_186278]]]]],[return,_186278]]]]]],['_tail'=_186500,'_head'=_186494,'_list'=_186464,'_meta'=_186338,'_else'=_186278,'_then'=_186272,'_atom'=_186266],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(707,0),line_char(716,26))). -user:metta_file_buffer(7,284000748,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(718,1),line_char(718,3))). -user:metta_file_buffer(7,284000748,constant,'return-on-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(718,4),line_char(718,19))). -user:metta_file_buffer(7,284000748,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(718,20),line_char(718,38))). -user:metta_file_buffer(6,284000748,metta_other,[iz,'return-on-error','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(718,0),line_char(718,39))). -user:metta_file_buffer(7,285000749,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(719,1),line_char(719,5))). -user:metta_file_buffer(7,285000749,constant,'return-on-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(719,6),line_char(719,21))). -user:metta_file_buffer(8,285000750,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(720,3),line_char(720,8))). -user:metta_file_buffer(8,285000750,string,"Returns first argument if it is Empty or an error. Returns second argument otherwise.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(720,9),line_char(720,96))). -user:metta_file_buffer(7,285000750,metta_other,['@desc',"Returns first argument if it is Empty or an error. Returns second argument otherwise."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(720,2),line_char(720,97))). -user:metta_file_buffer(8,285000751,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(721,3),line_char(721,10))). -user:metta_file_buffer(10,285000753,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(722,5),line_char(722,11))). -user:metta_file_buffer(10,285000753,string,"Previous evaluation result",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(722,12),line_char(722,40))). -user:metta_file_buffer(9,285000753,metta_other,['@param',"Previous evaluation result"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(722,4),line_char(722,41))). -user:metta_file_buffer(10,285000754,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(723,5),line_char(723,11))). -user:metta_file_buffer(10,285000754,string,"Atom for further evaluation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(723,12),line_char(723,41))). -user:metta_file_buffer(9,285000754,metta_other,['@param',"Atom for further evaluation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(723,4),line_char(723,42))). -user:metta_file_buffer(8,285000754,array,[['@param',"Previous evaluation result"],['@param',"Atom for further evaluation"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(721,11),line_char(723,43))). -user:metta_file_buffer(7,285000754,metta_other,['@params',[['@param',"Previous evaluation result"],['@param',"Atom for further evaluation"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(721,2),line_char(723,44))). -user:metta_file_buffer(8,285000755,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(724,3),line_char(724,10))). -user:metta_file_buffer(8,285000755,string,"Return previous result if it is an error or Empty or continue evaluation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(724,11),line_char(724,85))). -user:metta_file_buffer(7,285000755,metta_other,['@return',"Return previous result if it is an error or Empty or continue evaluation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(724,2),line_char(724,86))). -user:metta_file_buffer(6,285000755,metta_other,['@doc','return-on-error',['@desc',"Returns first argument if it is Empty or an error. Returns second argument otherwise."],['@params',[['@param',"Previous evaluation result"],['@param',"Atom for further evaluation"]]],['@return',"Return previous result if it is an error or Empty or continue evaluation"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(719,0),line_char(724,87))). -user:metta_file_buffer(7,286000756,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(725,1),line_char(725,2))). -user:metta_file_buffer(7,286000756,constant,'return-on-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(725,3),line_char(725,18))). -user:metta_file_buffer(8,286000757,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(725,20),line_char(725,22))). -user:metta_file_buffer(8,286000757,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(725,23),line_char(725,27))). -user:metta_file_buffer(8,286000757,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(725,28),line_char(725,32))). -user:metta_file_buffer(8,286000757,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(725,33),line_char(725,37))). -user:metta_file_buffer(7,286000757,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(725,19),line_char(725,38))). -user:metta_file_buffer(6,286000757,metta_typedecl,[:,'return-on-error',[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(725,0),line_char(725,39))). -user:metta_file_buffer(7,287000758,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(726,1),line_char(726,2))). -user:metta_file_buffer(8,287000759,constant,'return-on-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(726,4),line_char(726,19))). -user:metta_file_buffer(8,287000759,variable,_128054,['_atom'=_128054],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(726,20),line_char(726,25))). -user:metta_file_buffer(8,287000759,variable,_129346,['_then'=_129346],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(726,26),line_char(726,31))). -user:metta_file_buffer(7,287000759,indexed(metta_other,['return-on-error',_130186,_130208]),['return-on-error',_130260,_130266],['_then'=_130266,'_atom'=_130260],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(726,3),line_char(726,32))). -user:metta_file_buffer(8,287000760,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,3),line_char(727,11))). -user:metta_file_buffer(9,287000761,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,13),line_char(727,17))). -user:metta_file_buffer(10,287000762,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,19),line_char(727,27))). -user:metta_file_buffer(10,287000762,variable,_133648,['_atom'=_133648],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,28),line_char(727,33))). -user:metta_file_buffer(10,287000762,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,34),line_char(727,39))). -user:metta_file_buffer(11,287000763,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,41),line_char(727,47))). -user:metta_file_buffer(12,287000764,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,49),line_char(727,55))). -user:metta_file_buffer(12,287000764,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,56),line_char(727,61))). -user:metta_file_buffer(11,287000764,metta_other,[return,'Empty'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,48),line_char(727,62))). -user:metta_file_buffer(10,287000764,metta_other,[return,[return,'Empty']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,40),line_char(727,63))). -user:metta_file_buffer(11,287000765,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(728,5),line_char(728,9))). -user:metta_file_buffer(12,287000766,constant,'if-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(728,11),line_char(728,19))). -user:metta_file_buffer(12,287000766,variable,_140420,['_atom'=_140420],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(728,20),line_char(728,25))). -user:metta_file_buffer(13,287000767,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(728,27),line_char(728,33))). -user:metta_file_buffer(14,287000768,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(728,35),line_char(728,41))). -user:metta_file_buffer(14,287000768,variable,_143340,['_atom'=_143340],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(728,42),line_char(728,47))). -user:metta_file_buffer(13,287000768,indexed(metta_other,[return,_144174]),[return,_144226],['_atom'=_144226],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(728,34),line_char(728,48))). -user:metta_file_buffer(12,287000768,indexed(metta_other,[return,[return,_144764]]),[return,[return,_144828]],['_atom'=_144828],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(728,26),line_char(728,49))). -user:metta_file_buffer(13,287000769,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(729,7),line_char(729,13))). -user:metta_file_buffer(13,287000769,variable,_146634,['_then'=_146634],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(729,14),line_char(729,19))). -user:metta_file_buffer(12,287000769,indexed(metta_other,[return,_147468]),[return,_147520],['_then'=_147520],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(729,6),line_char(729,20))). -user:metta_file_buffer(11,287000769,indexed(metta_other,['if-error',_148056,[return,[return,_148056]],[return,_148144]]),['if-error',_148196,[return,[return,_148196]],[return,_148244]],['_then'=_148244,'_atom'=_148196],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(728,10),line_char(729,22))). -user:metta_file_buffer(10,287000769,indexed(metta_other,[eval,['if-error',_148794,[return,[return,_148794]],[return,_148882]]]),[eval,['if-error',_148946,[return,[return,_148946]],[return,_148994]]],['_then'=_148994,'_atom'=_148946],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(728,4),line_char(729,23))). -user:metta_file_buffer(9,287000769,indexed(metta_other,['if-equal',_149546,'Empty',[return,[return,'Empty']],[eval,['if-error',_149546,[return,[return,_149546]],[return,_149732]]]]),['if-equal',_149784,'Empty',[return,[return,'Empty']],[eval,['if-error',_149784,[return,[return,_149784]],[return,_149874]]]],['_then'=_149874,'_atom'=_149784],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,18),line_char(729,24))). -user:metta_file_buffer(8,287000769,indexed(metta_other,[eval,['if-equal',_150424,'Empty',[return,[return,'Empty']],[eval,['if-error',_150424,[return,[return,_150424]],[return,_150610]]]]]),[eval,['if-equal',_150674,'Empty',[return,[return,'Empty']],[eval,['if-error',_150674,[return,[return,_150674]],[return,_150764]]]]],['_then'=_150764,'_atom'=_150674],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,12),line_char(729,25))). -user:metta_file_buffer(7,287000769,indexed(metta_other,[function,[eval,['if-equal',_151330,'Empty',[return,[return,'Empty']],[eval,['if-error',_151330,[return,[return,_151330]],[return,_151516]]]]]]),[function,[eval,['if-equal',_151592,'Empty',[return,[return,'Empty']],[eval,['if-error',_151592,[return,[return,_151592]],[return,_151682]]]]]],['_then'=_151682,'_atom'=_151592],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(727,2),line_char(729,26))). -user:metta_file_buffer(6,287000769,indexed(metta_defun,['return-on-error',_152238,_152260]),[=,['return-on-error',_152572,_152578],[function,[eval,['if-equal',_152572,'Empty',[return,[return,'Empty']],[eval,['if-error',_152572,[return,[return,_152572]],[return,_152578]]]]]]],['_then'=_152578,'_atom'=_152572],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(726,0),line_char(729,27))). -user:metta_file_buffer(6,288000769,indexed(metta_comment,"; Difference between `switch` and `case` is a way how they interpret `Empty`"),'$COMMENT'("; Difference between `switch` and `case` is a way how they interpret `Empty`",732,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(732,0),line_char(732,76))). -user:metta_file_buffer(6,288000769,indexed(metta_comment,"; result. `CaseOp` interprets first argument inside itself and then manually"),'$COMMENT'("; result. `CaseOp` interprets first argument inside itself and then manually",733,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(733,0),line_char(733,76))). -user:metta_file_buffer(6,288000769,indexed(metta_comment,"; checks whether result is empty. `switch` is interpreted in a context of"),'$COMMENT'("; checks whether result is empty. `switch` is interpreted in a context of",734,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(734,0),line_char(734,73))). -user:metta_file_buffer(6,288000769,indexed(metta_comment,"; main interpreter. Minimal interpreter correctly passes `Empty` as an"),'$COMMENT'("; main interpreter. Minimal interpreter correctly passes `Empty` as an",735,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(735,0),line_char(735,70))). -user:metta_file_buffer(6,288000769,indexed(metta_comment,"; argument to the `switch` but when `switch` is called from MeTTa interpreter"),'$COMMENT'("; argument to the `switch` but when `switch` is called from MeTTa interpreter",736,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(736,0),line_char(736,77))). -user:metta_file_buffer(6,288000769,indexed(metta_comment,"; (for example user evaluates `!(switch (if-unify A B ok Empty) ...)` then"),'$COMMENT'("; (for example user evaluates `!(switch (if-unify A B ok Empty) ...)` then",737,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(737,0),line_char(737,74))). -user:metta_file_buffer(6,288000769,indexed(metta_comment,"; emptiness of the first argument is checked by interpreter and it will"),'$COMMENT'("; emptiness of the first argument is checked by interpreter and it will",738,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(738,0),line_char(738,71))). -user:metta_file_buffer(6,288000769,indexed(metta_comment,"; break execution when `Empty` is returned."),'$COMMENT'("; break execution when `Empty` is returned.",739,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(739,0),line_char(739,43))). -user:metta_file_buffer(7,288000770,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(741,1),line_char(741,3))). -user:metta_file_buffer(7,288000770,constant,switch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(741,4),line_char(741,10))). -user:metta_file_buffer(7,288000770,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(741,11),line_char(741,29))). -user:metta_file_buffer(6,288000770,metta_other,[iz,switch,'MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(741,0),line_char(741,30))). -user:metta_file_buffer(7,289000771,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(742,1),line_char(742,5))). -user:metta_file_buffer(7,289000771,constant,switch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(742,6),line_char(742,12))). -user:metta_file_buffer(8,289000772,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(743,3),line_char(743,8))). -user:metta_file_buffer(8,289000772,string,"Subsequently tests multiple pattern-matching conditions (second argument) for the given value (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(743,9),line_char(743,121))). -user:metta_file_buffer(7,289000772,metta_other,['@desc',"Subsequently tests multiple pattern-matching conditions (second argument) for the given value (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(743,2),line_char(743,122))). -user:metta_file_buffer(8,289000773,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(744,3),line_char(744,10))). -user:metta_file_buffer(10,289000775,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(745,5),line_char(745,11))). -user:metta_file_buffer(10,289000775,string,"Atom to be matched with patterns",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(745,12),line_char(745,46))). -user:metta_file_buffer(9,289000775,metta_other,['@param',"Atom to be matched with patterns"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(745,4),line_char(745,47))). -user:metta_file_buffer(10,289000776,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(746,5),line_char(746,11))). -user:metta_file_buffer(10,289000776,string,"Tuple of pairs mapping condition patterns to results",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(746,12),line_char(746,66))). -user:metta_file_buffer(9,289000776,metta_other,['@param',"Tuple of pairs mapping condition patterns to results"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(746,4),line_char(746,67))). -user:metta_file_buffer(8,289000776,array,[['@param',"Atom to be matched with patterns"],['@param',"Tuple of pairs mapping condition patterns to results"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(744,11),line_char(746,68))). -user:metta_file_buffer(7,289000776,metta_other,['@params',[['@param',"Atom to be matched with patterns"],['@param',"Tuple of pairs mapping condition patterns to results"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(744,2),line_char(746,69))). -user:metta_file_buffer(8,289000777,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(747,3),line_char(747,10))). -user:metta_file_buffer(8,289000777,string,"Result which corresponds to the pattern which is matched with the passed atom first",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(747,11),line_char(747,96))). -user:metta_file_buffer(7,289000777,metta_other,['@return',"Result which corresponds to the pattern which is matched with the passed atom first"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(747,2),line_char(747,97))). -user:metta_file_buffer(6,289000777,metta_other,['@doc',switch,['@desc',"Subsequently tests multiple pattern-matching conditions (second argument) for the given value (first argument)"],['@params',[['@param',"Atom to be matched with patterns"],['@param',"Tuple of pairs mapping condition patterns to results"]]],['@return',"Result which corresponds to the pattern which is matched with the passed atom first"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(742,0),line_char(747,98))). -user:metta_file_buffer(7,290000778,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(749,1),line_char(749,2))). -user:metta_file_buffer(7,290000778,constant,switch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(749,3),line_char(749,9))). -user:metta_file_buffer(8,290000779,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(749,11),line_char(749,13))). -user:metta_file_buffer(8,290000779,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(749,14),line_char(749,18))). -user:metta_file_buffer(8,290000779,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(749,19),line_char(749,23))). -user:metta_file_buffer(8,290000779,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(749,24),line_char(749,28))). -user:metta_file_buffer(7,290000779,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(749,10),line_char(749,29))). -user:metta_file_buffer(6,290000779,metta_typedecl,[:,switch,[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(749,0),line_char(749,30))). -user:metta_file_buffer(7,291000780,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(750,1),line_char(750,2))). -user:metta_file_buffer(8,291000781,constant,switch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(750,4),line_char(750,10))). -user:metta_file_buffer(8,291000781,variable,_128032,['_atom'=_128032],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(750,11),line_char(750,16))). -user:metta_file_buffer(8,291000781,variable,_129324,['_list'=_129324],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(750,17),line_char(750,22))). -user:metta_file_buffer(7,291000781,indexed(metta_other,[switch,_130164,_130186]),[switch,_130238,_130244],['_list'=_130244,'_atom'=_130238],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(750,3),line_char(750,23))). -user:metta_file_buffer(8,291000782,constant,case,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(750,25),line_char(750,29))). -user:metta_file_buffer(9,291000783,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(750,31),line_char(750,35))). -user:metta_file_buffer(9,291000783,variable,_132824,['_atom'=_132824],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(750,36),line_char(750,41))). -user:metta_file_buffer(8,291000783,indexed(metta_other,[eval,_133658]),[eval,_133710],['_atom'=_133710],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(750,30),line_char(750,42))). -user:metta_file_buffer(8,291000783,variable,_134690,['_list'=_134690],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(750,43),line_char(750,48))). -user:metta_file_buffer(7,291000783,indexed(metta_other,[case,[eval,_135546],_135568]),[case,[eval,_135632],_135638],['_list'=_135638,'_atom'=_135632],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(750,24),line_char(750,49))). -user:metta_file_buffer(6,291000783,indexed(metta_defun,[switch,_136194,_136216]),[=,[switch,_136348,_136354],[case,[eval,_136348],_136354]],['_list'=_136354,'_atom'=_136348],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(750,0),line_char(750,50))). -user:metta_file_buffer(6,292000783,indexed(metta_comment,"; BEGIN - Yes, Douglas turned this sourcecode form into a a Value with the type Comment"),'$COMMENT'("; BEGIN - Yes, Douglas turned this sourcecode form into a a Value with the type Comment",755,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(755,0),line_char(755,87))). -user:metta_file_buffer(7,292000784,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(756,1),line_char(756,2))). -user:metta_file_buffer(9,292000786,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(757,1),line_char(757,2))). -user:metta_file_buffer(9,292000786,constant,switch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(757,3),line_char(757,9))). -user:metta_file_buffer(10,292000787,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(757,11),line_char(757,13))). -user:metta_file_buffer(10,292000787,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(757,14),line_char(757,25))). -user:metta_file_buffer(10,292000787,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(757,26),line_char(757,36))). -user:metta_file_buffer(10,292000787,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(757,37),line_char(757,41))). -user:metta_file_buffer(9,292000787,metta_other,[->,'%Undefined%','Expression','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(757,10),line_char(757,42))). -user:metta_file_buffer(8,292000787,metta_typedecl,[:,switch,[->,'%Undefined%','Expression','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(757,0),line_char(757,43))). -user:metta_file_buffer(9,292000788,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(758,1),line_char(758,2))). -user:metta_file_buffer(10,292000789,constant,switch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(758,4),line_char(758,10))). -user:metta_file_buffer(10,292000789,variable,_134946,['_atom'=_134946],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(758,11),line_char(758,16))). -user:metta_file_buffer(10,292000789,variable,_136254,['_cases'=_136254],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(758,17),line_char(758,23))). -user:metta_file_buffer(9,292000789,indexed(metta_other,[switch,_137094,_137116]),[switch,_137168,_137174],['_cases'=_137174,'_atom'=_137168],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(758,3),line_char(758,24))). -user:metta_file_buffer(10,292000790,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(759,3),line_char(759,11))). -user:metta_file_buffer(11,292000791,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(759,13),line_char(759,18))). -user:metta_file_buffer(12,292000792,constant,'decons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(759,20),line_char(759,31))). -user:metta_file_buffer(12,292000792,variable,_140620,['_cases'=_140620],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(759,32),line_char(759,38))). -user:metta_file_buffer(11,292000792,indexed(metta_other,['decons-atom',_141454]),['decons-atom',_141506],['_cases'=_141506],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(759,19),line_char(759,39))). -user:metta_file_buffer(11,292000792,variable,_142478,['_list'=_142478],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(759,40),line_char(759,45))). -user:metta_file_buffer(12,292000793,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(760,5),line_char(760,10))). -user:metta_file_buffer(13,292000794,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(760,12),line_char(760,16))). -user:metta_file_buffer(14,292000795,constant,'switch-internal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(760,18),line_char(760,33))). -user:metta_file_buffer(14,292000795,variable,_146204,['_atom'=_146204],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(760,34),line_char(760,39))). -user:metta_file_buffer(14,292000795,variable,_147496,['_list'=_147496],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(760,40),line_char(760,45))). -user:metta_file_buffer(13,292000795,indexed(metta_other,['switch-internal',_148336,_148358]),['switch-internal',_148410,_148416],['_list'=_148416,'_atom'=_148410],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(760,17),line_char(760,46))). -user:metta_file_buffer(12,292000795,indexed(metta_other,[eval,['switch-internal',_148966,_148988]]),[eval,['switch-internal',_149052,_149058]],['_list'=_149058,'_atom'=_149052],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(760,11),line_char(760,47))). -user:metta_file_buffer(12,292000795,variable,_150026,['_res'=_150026],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(760,48),line_char(760,52))). -user:metta_file_buffer(13,292000796,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,7),line_char(761,12))). -user:metta_file_buffer(14,292000797,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,14),line_char(761,18))). -user:metta_file_buffer(15,292000798,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,20),line_char(761,28))). -user:metta_file_buffer(15,292000798,variable,_153670,['_res'=_153670],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,29),line_char(761,33))). -user:metta_file_buffer(15,292000798,constant,'NotReducible',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,34),line_char(761,46))). -user:metta_file_buffer(15,292000798,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,47),line_char(761,52))). -user:metta_file_buffer(15,292000798,variable,_156212,['_res'=_156212],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,53),line_char(761,57))). -user:metta_file_buffer(14,292000798,indexed(metta_other,['if-equal',_157064,'NotReducible','Empty',_157064]),['if-equal',_157150,'NotReducible','Empty',_157150],['_res'=_157150],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,19),line_char(761,58))). -user:metta_file_buffer(13,292000798,indexed(metta_other,[eval,['if-equal',_157706,'NotReducible','Empty',_157706]]),[eval,['if-equal',_157804,'NotReducible','Empty',_157804]],['_res'=_157804],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,13),line_char(761,59))). -user:metta_file_buffer(13,292000798,variable,_158746,['_x'=_158746],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,60),line_char(761,62))). -user:metta_file_buffer(14,292000799,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,64),line_char(761,70))). -user:metta_file_buffer(14,292000799,variable,_160804,['_x'=_160804],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,71),line_char(761,73))). -user:metta_file_buffer(13,292000799,indexed(metta_other,[return,_161638]),[return,_161690],['_x'=_161690],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,63),line_char(761,74))). -user:metta_file_buffer(12,292000799,indexed(metta_other,[chain,[eval,['if-equal',_162256,'NotReducible','Empty',_162256]],_162312,[return,_162312]]),[chain,[eval,['if-equal',_162422,'NotReducible','Empty',_162422]],_162446,[return,_162446]],['_x'=_162446,'_res'=_162422],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(761,6),line_char(761,75))). -user:metta_file_buffer(11,292000799,indexed(metta_other,[chain,[eval,['switch-internal',_163044,_163066]],_163088,[chain,[eval,['if-equal',_163088,'NotReducible','Empty',_163088]],_163210,[return,_163210]]]),[chain,[eval,['switch-internal',_163320,_163326]],_163332,[chain,[eval,['if-equal',_163332,'NotReducible','Empty',_163332]],_163398,[return,_163398]]],['_x'=_163398,'_res'=_163332,'_list'=_163326,'_atom'=_163320],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(760,4),line_char(761,77))). -user:metta_file_buffer(10,292000799,indexed(metta_other,[chain,['decons-atom',_164002],_164024,[chain,[eval,['switch-internal',_164094,_164024]],_164134,[chain,[eval,['if-equal',_164134,'NotReducible','Empty',_164134]],_164256,[return,_164256]]]]),[chain,['decons-atom',_164354],_164360,[chain,[eval,['switch-internal',_164402,_164360]],_164414,[chain,[eval,['if-equal',_164414,'NotReducible','Empty',_164414]],_164480,[return,_164480]]]],['_x'=_164480,'_res'=_164414,'_atom'=_164402,'_list'=_164360,'_cases'=_164354],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(759,12),line_char(761,78))). -user:metta_file_buffer(9,292000799,indexed(metta_other,[function,[chain,['decons-atom',_165100],_165122,[chain,[eval,['switch-internal',_165192,_165122]],_165232,[chain,[eval,['if-equal',_165232,'NotReducible','Empty',_165232]],_165354,[return,_165354]]]]]),[function,[chain,['decons-atom',_165464],_165470,[chain,[eval,['switch-internal',_165512,_165470]],_165524,[chain,[eval,['if-equal',_165524,'NotReducible','Empty',_165524]],_165590,[return,_165590]]]]],['_x'=_165590,'_res'=_165524,'_atom'=_165512,'_list'=_165470,'_cases'=_165464],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(759,2),line_char(761,79))). -user:metta_file_buffer(8,292000799,indexed(metta_defun,[switch,_166200,_166222]),[=,[switch,_166636,_166642],[function,[chain,['decons-atom',_166642],_166690,[chain,[eval,['switch-internal',_166636,_166690]],_166744,[chain,[eval,['if-equal',_166744,'NotReducible','Empty',_166744]],_166810,[return,_166810]]]]]],['_x'=_166810,'_res'=_166744,'_list'=_166690,'_cases'=_166642,'_atom'=_166636],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(758,0),line_char(761,80))). -user:metta_file_buffer(9,292000800,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(763,1),line_char(763,3))). -user:metta_file_buffer(9,292000800,constant,'switch-internal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(763,4),line_char(763,19))). -user:metta_file_buffer(9,292000800,constant,'HelperMM',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(763,20),line_char(763,28))). -user:metta_file_buffer(8,292000800,metta_other,[iz,'switch-internal','HelperMM'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(763,0),line_char(763,29))). -user:metta_file_buffer(9,292000801,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(764,1),line_char(764,5))). -user:metta_file_buffer(9,292000801,constant,'switch-internal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(764,6),line_char(764,21))). -user:metta_file_buffer(10,292000802,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(765,3),line_char(765,8))). -user:metta_file_buffer(10,292000802,string,"This function is being called inside switch function to test one of the cases and it calls switch once again if current condition is not met",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(765,9),line_char(765,151))). -user:metta_file_buffer(9,292000802,metta_other,['@desc',"This function is being called inside switch function to test one of the cases and it calls switch once again if current condition is not met"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(765,2),line_char(765,152))). -user:metta_file_buffer(10,292000803,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(766,3),line_char(766,10))). -user:metta_file_buffer(12,292000805,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(767,5),line_char(767,11))). -user:metta_file_buffer(12,292000805,string,"Atom (it will be evaluated)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(767,12),line_char(767,41))). -user:metta_file_buffer(11,292000805,metta_other,['@param',"Atom (it will be evaluated)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(767,4),line_char(767,42))). -user:metta_file_buffer(12,292000806,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(768,5),line_char(768,11))). -user:metta_file_buffer(12,292000806,string,"Deconsed tuple of pairs mapping condition patterns to results",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(768,12),line_char(768,75))). -user:metta_file_buffer(11,292000806,metta_other,['@param',"Deconsed tuple of pairs mapping condition patterns to results"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(768,4),line_char(768,76))). -user:metta_file_buffer(10,292000806,array,[['@param',"Atom (it will be evaluated)"],['@param',"Deconsed tuple of pairs mapping condition patterns to results"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(766,11),line_char(768,77))). -user:metta_file_buffer(9,292000806,metta_other,['@params',[['@param',"Atom (it will be evaluated)"],['@param',"Deconsed tuple of pairs mapping condition patterns to results"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(766,2),line_char(768,78))). -user:metta_file_buffer(10,292000807,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(769,3),line_char(769,10))). -user:metta_file_buffer(10,292000807,string,"Result of evaluating of Atom bound to met condition",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(769,11),line_char(769,64))). -user:metta_file_buffer(9,292000807,metta_other,['@return',"Result of evaluating of Atom bound to met condition"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(769,2),line_char(769,65))). -user:metta_file_buffer(8,292000807,metta_other,['@doc','switch-internal',['@desc',"This function is being called inside switch function to test one of the cases and it calls switch once again if current condition is not met"],['@params',[['@param',"Atom (it will be evaluated)"],['@param',"Deconsed tuple of pairs mapping condition patterns to results"]]],['@return',"Result of evaluating of Atom bound to met condition"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(764,0),line_char(769,66))). -user:metta_file_buffer(9,292000808,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(770,1),line_char(770,2))). -user:metta_file_buffer(10,292000809,constant,'switch-internal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(770,4),line_char(770,19))). -user:metta_file_buffer(10,292000809,variable,_186496,['_atom'=_186496],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(770,20),line_char(770,25))). -user:metta_file_buffer(12,292000811,variable,_188120,['_pattern'=_188120],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(770,28),line_char(770,36))). -user:metta_file_buffer(12,292000811,variable,_189492,['_template'=_189492],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(770,37),line_char(770,46))). -user:metta_file_buffer(11,292000811,indexed(metta_other,[_190318,_190340]),[_190386,_190392],['_template'=_190392,'_pattern'=_190386],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(770,27),line_char(770,47))). -user:metta_file_buffer(11,292000811,variable,_191384,['_tail'=_191384],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(770,48),line_char(770,53))). -user:metta_file_buffer(10,292000811,indexed(array,[[_192218,_192240],_192262]),[[_192314,_192320],_192326],['_tail'=_192326,'_template'=_192320,'_pattern'=_192314],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(770,26),line_char(770,54))). -user:metta_file_buffer(9,292000811,indexed(metta_other,['switch-internal',_192884,[[_192922,_192944],_192966]]),['switch-internal',_193018,[[_193036,_193042],_193048]],['_tail'=_193048,'_template'=_193042,'_pattern'=_193036,'_atom'=_193018],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(770,3),line_char(770,55))). -user:metta_file_buffer(10,292000812,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(771,3),line_char(771,11))). -user:metta_file_buffer(11,292000813,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(771,13),line_char(771,21))). -user:metta_file_buffer(11,292000813,variable,_195660,['_atom'=_195660],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(771,22),line_char(771,27))). -user:metta_file_buffer(11,292000813,variable,_197008,['_pattern'=_197008],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(771,28),line_char(771,36))). -user:metta_file_buffer(12,292000814,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(772,5),line_char(772,11))). -user:metta_file_buffer(12,292000814,variable,_199202,['_template'=_199202],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(772,12),line_char(772,21))). -user:metta_file_buffer(11,292000814,indexed(metta_other,[return,_200036]),[return,_200088],['_template'=_200088],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(772,4),line_char(772,22))). -user:metta_file_buffer(12,292000815,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(773,5),line_char(773,10))). -user:metta_file_buffer(13,292000816,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(773,12),line_char(773,16))). -user:metta_file_buffer(14,292000817,constant,switch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(773,18),line_char(773,24))). -user:metta_file_buffer(14,292000817,variable,_203480,['_atom'=_203480],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(773,25),line_char(773,30))). -user:metta_file_buffer(14,292000817,variable,_204772,['_tail'=_204772],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(773,31),line_char(773,36))). -user:metta_file_buffer(13,292000817,indexed(metta_other,[switch,_205612,_205634]),[switch,_205686,_205692],['_tail'=_205692,'_atom'=_205686],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(773,17),line_char(773,37))). -user:metta_file_buffer(12,292000817,indexed(metta_other,[eval,[switch,_206242,_206264]]),[eval,[switch,_206328,_206334]],['_tail'=_206334,'_atom'=_206328],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(773,11),line_char(773,38))). -user:metta_file_buffer(12,292000817,variable,_207302,['_ret'=_207302],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(773,39),line_char(773,43))). -user:metta_file_buffer(13,292000818,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(773,45),line_char(773,51))). -user:metta_file_buffer(13,292000818,variable,_209392,['_ret'=_209392],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(773,52),line_char(773,56))). -user:metta_file_buffer(12,292000818,indexed(metta_other,[return,_210226]),[return,_210278],['_ret'=_210278],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(773,44),line_char(773,57))). -user:metta_file_buffer(11,292000818,indexed(metta_other,[chain,[eval,[switch,_210844,_210866]],_210888,[return,_210888]]),[chain,[eval,[switch,_210998,_211004]],_211010,[return,_211010]],['_ret'=_211010,'_tail'=_211004,'_atom'=_210998],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(773,4),line_char(773,58))). -user:metta_file_buffer(10,292000818,indexed(metta_other,['if-unify',_211594,_211616,[return,_211654],[chain,[eval,[switch,_211594,_211742]],_211764,[return,_211764]]]),['if-unify',_211850,_211856,[return,_211874],[chain,[eval,[switch,_211850,_211922]],_211928,[return,_211928]]],['_ret'=_211928,'_tail'=_211922,'_template'=_211874,'_pattern'=_211856,'_atom'=_211850],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(771,12),line_char(773,60))). -user:metta_file_buffer(9,292000818,indexed(metta_other,[function,['if-unify',_212532,_212554,[return,_212592],[chain,[eval,[switch,_212532,_212680]],_212702,[return,_212702]]]]),[function,['if-unify',_212800,_212806,[return,_212824],[chain,[eval,[switch,_212800,_212872]],_212878,[return,_212878]]]],['_ret'=_212878,'_tail'=_212872,'_template'=_212824,'_pattern'=_212806,'_atom'=_212800],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(771,2),line_char(773,61))). -user:metta_file_buffer(8,292000818,indexed(metta_defun,['switch-internal',_213488,[[_213526,_213548],_213570]]),[=,['switch-internal',_213876,[[_213894,_213900],_213906]],[function,['if-unify',_213876,_213894,[return,_213900],[chain,[eval,[switch,_213876,_213906]],_214014,[return,_214014]]]]],['_ret'=_214014,'_tail'=_213906,'_template'=_213900,'_pattern'=_213894,'_atom'=_213876],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(770,0),line_char(773,62))). -user:metta_file_buffer(7,292000818,indexed(array,[[:,switch,[->,'%Undefined%','Expression','Atom']],[=,[switch,_214712,_214734],[function,[chain,['decons-atom',_214734],_214822,[chain,[eval,['switch-internal',_214712,_214822]],_214928,[chain,[eval,['if-equal',_214928,'NotReducible','Empty',_214928]],_215050,[return,_215050]]]]]],[iz,'switch-internal','HelperMM'],['@doc','switch-internal',['@desc',"This function is being called inside switch function to test one of the cases and it calls switch once again if current condition is not met"],['@params',[['@param',"Atom (it will be evaluated)"],['@param',"Deconsed tuple of pairs mapping condition patterns to results"]]],['@return',"Result of evaluating of Atom bound to met condition"]],[=,['switch-internal',_214712,[[_215348,_215370],_215392]],[function,['if-unify',_214712,_215348,[return,_215370],[chain,[eval,[switch,_214712,_215392]],_215600,[return,_215600]]]]]]),[[:,switch,[->,'%Undefined%','Expression','Atom']],[=,[switch,_215710,_215716],[function,[chain,['decons-atom',_215716],_215764,[chain,[eval,['switch-internal',_215710,_215764]],_215818,[chain,[eval,['if-equal',_215818,'NotReducible','Empty',_215818]],_215884,[return,_215884]]]]]],[iz,'switch-internal','HelperMM'],['@doc','switch-internal',['@desc',"This function is being called inside switch function to test one of the cases and it calls switch once again if current condition is not met"],['@params',[['@param',"Atom (it will be evaluated)"],['@param',"Deconsed tuple of pairs mapping condition patterns to results"]]],['@return',"Result of evaluating of Atom bound to met condition"]],[=,['switch-internal',_215710,[[_215962,_215968],_215974]],[function,['if-unify',_215710,_215962,[return,_215968],[chain,[eval,[switch,_215710,_215974]],_216082,[return,_216082]]]]]],['_ret'=_216082,'_tail'=_215974,'_template'=_215968,'_pattern'=_215962,'_x'=_215884,'_res'=_215818,'_list'=_215764,'_cases'=_215716,'_atom'=_215710],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(756,3),line_char(775,1))). -user:metta_file_buffer(7,292000818,constant,'Comment',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(775,2),line_char(775,9))). -user:metta_file_buffer(6,292000818,indexed(metta_typedecl,[:,[[:,switch,[->,'%Undefined%','Expression','Atom']],[=,[switch,_217460,_217482],[function,[chain,['decons-atom',_217482],_217570,[chain,[eval,['switch-internal',_217460,_217570]],_217676,[chain,[eval,['if-equal',_217676,'NotReducible','Empty',_217676]],_217798,[return,_217798]]]]]],[iz,'switch-internal','HelperMM'],['@doc','switch-internal',['@desc',"This function is being called inside switch function to test one of the cases and it calls switch once again if current condition is not met"],['@params',[['@param',"Atom (it will be evaluated)"],['@param',"Deconsed tuple of pairs mapping condition patterns to results"]]],['@return',"Result of evaluating of Atom bound to met condition"]],[=,['switch-internal',_217460,[[_218096,_218118],_218140]],[function,['if-unify',_217460,_218096,[return,_218118],[chain,[eval,[switch,_217460,_218140]],_218348,[return,_218348]]]]]],'Comment']),[:,[[:,switch,[->,'%Undefined%','Expression','Atom']],[=,[switch,_218478,_218484],[function,[chain,['decons-atom',_218484],_218532,[chain,[eval,['switch-internal',_218478,_218532]],_218586,[chain,[eval,['if-equal',_218586,'NotReducible','Empty',_218586]],_218652,[return,_218652]]]]]],[iz,'switch-internal','HelperMM'],['@doc','switch-internal',['@desc',"This function is being called inside switch function to test one of the cases and it calls switch once again if current condition is not met"],['@params',[['@param',"Atom (it will be evaluated)"],['@param',"Deconsed tuple of pairs mapping condition patterns to results"]]],['@return',"Result of evaluating of Atom bound to met condition"]],[=,['switch-internal',_218478,[[_218730,_218736],_218742]],[function,['if-unify',_218478,_218730,[return,_218736],[chain,[eval,[switch,_218478,_218742]],_218850,[return,_218850]]]]]],'Comment'],['_ret'=_218850,'_tail'=_218742,'_template'=_218736,'_pattern'=_218730,'_x'=_218652,'_res'=_218586,'_list'=_218532,'_cases'=_218484,'_atom'=_218478],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(756,0),line_char(775,10))). -user:metta_file_buffer(6,293000818,indexed(metta_comment,"; ENDOF - Yes, Douglas turned this sourcecode form into a a Value with the type Comment"),'$COMMENT'("; ENDOF - Yes, Douglas turned this sourcecode form into a a Value with the type Comment",776,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(776,0),line_char(776,87))). -user:metta_file_buffer(7,293000819,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(779,1),line_char(779,3))). -user:metta_file_buffer(7,293000819,constant,'is-function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(779,4),line_char(779,15))). -user:metta_file_buffer(7,293000819,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(779,16),line_char(779,34))). -user:metta_file_buffer(6,293000819,metta_other,[iz,'is-function','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(779,0),line_char(779,35))). -user:metta_file_buffer(6,294000819,indexed(metta_comment,"; TODO: Type is used here, but there is no definition for the -> type"),'$COMMENT'("; TODO: Type is used here, but there is no definition for the -> type",780,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(780,0),line_char(780,69))). -user:metta_file_buffer(6,294000819,indexed(metta_comment,"; constructor for instance, thus in practice it matches because -> has"),'$COMMENT'("; constructor for instance, thus in practice it matches because -> has",781,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(781,0),line_char(781,70))). -user:metta_file_buffer(6,294000819,indexed(metta_comment,"; %Undefined% type. We need to assign proper type to -> and other type"),'$COMMENT'("; %Undefined% type. We need to assign proper type to -> and other type",782,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(782,0),line_char(782,70))). -user:metta_file_buffer(6,294000819,indexed(metta_comment,"; constructors but it is not possible until we support vararg types."),'$COMMENT'("; constructors but it is not possible until we support vararg types.",783,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(783,0),line_char(783,68))). -user:metta_file_buffer(7,294000820,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(784,1),line_char(784,5))). -user:metta_file_buffer(7,294000820,constant,'is-function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(784,6),line_char(784,17))). -user:metta_file_buffer(8,294000821,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(785,3),line_char(785,8))). -user:metta_file_buffer(8,294000821,string,"Function checks if input type is a function type",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(785,9),line_char(785,59))). -user:metta_file_buffer(7,294000821,metta_other,['@desc',"Function checks if input type is a function type"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(785,2),line_char(785,60))). -user:metta_file_buffer(8,294000822,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(786,3),line_char(786,10))). -user:metta_file_buffer(10,294000824,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(787,5),line_char(787,11))). -user:metta_file_buffer(10,294000824,string,"Type atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(787,12),line_char(787,23))). -user:metta_file_buffer(9,294000824,metta_other,['@param',"Type atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(787,4),line_char(787,24))). -user:metta_file_buffer(8,294000824,array,[['@param',"Type atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(786,11),line_char(787,25))). -user:metta_file_buffer(7,294000824,metta_other,['@params',[['@param',"Type atom"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(786,2),line_char(787,26))). -user:metta_file_buffer(8,294000825,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(788,3),line_char(788,10))). -user:metta_file_buffer(8,294000825,string,"True if type is a function type, False - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(788,11),line_char(788,63))). -user:metta_file_buffer(7,294000825,metta_other,['@return',"True if type is a function type, False - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(788,2),line_char(788,64))). -user:metta_file_buffer(6,294000825,metta_other,['@doc','is-function',['@desc',"Function checks if input type is a function type"],['@params',[['@param',"Type atom"]]],['@return',"True if type is a function type, False - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(784,0),line_char(788,65))). -user:metta_file_buffer(7,295000826,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(789,1),line_char(789,2))). -user:metta_file_buffer(7,295000826,constant,'is-function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(789,3),line_char(789,14))). -user:metta_file_buffer(8,295000827,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(789,16),line_char(789,18))). -user:metta_file_buffer(8,295000827,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(789,19),line_char(789,23))). -user:metta_file_buffer(8,295000827,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(789,24),line_char(789,28))). -user:metta_file_buffer(7,295000827,metta_other,[->,'Type','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(789,15),line_char(789,29))). -user:metta_file_buffer(6,295000827,metta_typedecl,[:,'is-function',[->,'Type','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(789,0),line_char(789,30))). -user:metta_file_buffer(6,296000827,indexed(metta_comment,";; This impl is old and maybe not sufficiant?"),'$COMMENT'(";; This impl is old and maybe not sufficiant?",790,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(790,0),line_char(790,45))). -user:metta_file_buffer(7,296000828,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(791,1),line_char(791,2))). -user:metta_file_buffer(8,296000829,constant,'is-function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(791,4),line_char(791,15))). -user:metta_file_buffer(8,296000829,variable,_132790,['_type'=_132790],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(791,16),line_char(791,21))). -user:metta_file_buffer(7,296000829,indexed(metta_other,['is-function',_133624]),['is-function',_133676],['_type'=_133676],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(791,3),line_char(791,22))). -user:metta_file_buffer(8,296000830,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(792,3),line_char(792,11))). -user:metta_file_buffer(9,296000831,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(792,13),line_char(792,18))). -user:metta_file_buffer(10,296000832,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(792,20),line_char(792,24))). -user:metta_file_buffer(11,296000833,constant,'get-metatype',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(792,26),line_char(792,38))). -user:metta_file_buffer(11,296000833,variable,_137898,['_type'=_137898],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(792,39),line_char(792,44))). -user:metta_file_buffer(10,296000833,indexed(metta_other,['get-metatype',_138732]),['get-metatype',_138784],['_type'=_138784],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(792,25),line_char(792,45))). -user:metta_file_buffer(9,296000833,indexed(metta_other,[eval,['get-metatype',_139322]]),[eval,['get-metatype',_139386]],['_type'=_139386],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(792,19),line_char(792,46))). -user:metta_file_buffer(9,296000833,variable,_140358,['_meta'=_140358],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(792,47),line_char(792,52))). -user:metta_file_buffer(10,296000834,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(793,5),line_char(793,9))). -user:metta_file_buffer(11,296000835,constant,switch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(793,11),line_char(793,17))). -user:metta_file_buffer(12,296000836,variable,_143396,['_type'=_143396],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(793,19),line_char(793,24))). -user:metta_file_buffer(12,296000836,variable,_144688,['_meta'=_144688],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(793,25),line_char(793,30))). -user:metta_file_buffer(11,296000836,indexed(metta_other,[_145514,_145536]),[_145582,_145588],['_meta'=_145588,'_type'=_145582],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(793,18),line_char(793,31))). -user:metta_file_buffer(14,296000839,variable,_147000,['_type'=_147000],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(794,8),line_char(794,13))). -user:metta_file_buffer(14,296000839,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(794,14),line_char(794,24))). -user:metta_file_buffer(13,296000839,indexed(metta_other,[_148482,'Expression']),[_148536,'Expression'],['_type'=_148536],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(794,7),line_char(794,25))). -user:metta_file_buffer(14,296000840,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(795,9),line_char(795,13))). -user:metta_file_buffer(15,296000841,constant,'if-decons-expr',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(795,15),line_char(795,29))). -user:metta_file_buffer(15,296000841,variable,_151144,['_type'=_151144],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(795,30),line_char(795,35))). -user:metta_file_buffer(15,296000841,variable,_152428,['_head'=_152428],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(795,36),line_char(795,41))). -user:metta_file_buffer(15,296000841,variable,_153432,['_tail'=_153432],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(795,42),line_char(795,48))). -user:metta_file_buffer(16,296000842,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(796,11),line_char(796,19))). -user:metta_file_buffer(16,296000842,variable,_155502,['_head'=_155502],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(796,20),line_char(796,25))). -user:metta_file_buffer(16,296000842,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(796,26),line_char(796,28))). -user:metta_file_buffer(17,296000843,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(796,30),line_char(796,36))). -user:metta_file_buffer(17,296000843,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(796,37),line_char(796,41))). -user:metta_file_buffer(16,296000843,metta_other,[return,'True'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(796,29),line_char(796,42))). -user:metta_file_buffer(17,296000844,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(796,44),line_char(796,50))). -user:metta_file_buffer(17,296000844,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(796,51),line_char(796,56))). -user:metta_file_buffer(16,296000844,metta_other,[return,'False'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(796,43),line_char(796,57))). -user:metta_file_buffer(15,296000844,indexed(metta_other,['if-unify',_160892,->,[return,'True'],[return,'False']]),['if-unify',_161000,->,[return,'True'],[return,'False']],['_head'=_161000],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(796,10),line_char(796,58))). -user:metta_file_buffer(16,296000845,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(797,11),line_char(797,17))). -user:metta_file_buffer(17,296000846,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(797,19),line_char(797,24))). -user:metta_file_buffer(18,296000847,constant,'is-function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(797,26),line_char(797,37))). -user:metta_file_buffer(18,296000847,variable,_164346,['_type'=_164346],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(797,38),line_char(797,43))). -user:metta_file_buffer(17,296000847,indexed(metta_other,['is-function',_165180]),['is-function',_165232],['_type'=_165232],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(797,25),line_char(797,44))). -user:metta_file_buffer(17,296000847,string,"is-function non-empty expression as an argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(797,45),line_char(797,94))). -user:metta_file_buffer(16,296000847,indexed(metta_other,['Error',['is-function',_166814],"is-function non-empty expression as an argument"]),['Error',['is-function',_166886],"is-function non-empty expression as an argument"],['_type'=_166886],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(797,18),line_char(797,95))). -user:metta_file_buffer(15,296000847,indexed(metta_other,[return,['Error',['is-function',_167440],"is-function non-empty expression as an argument"]]),[return,['Error',['is-function',_167524],"is-function non-empty expression as an argument"]],['_type'=_167524],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(797,10),line_char(797,96))). -user:metta_file_buffer(14,296000847,indexed(metta_other,['if-decons-expr',_168072,_168094,_168116,['if-unify',_168094,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_168072],"is-function non-empty expression as an argument"]]]),['if-decons-expr',_168332,_168338,_168344,['if-unify',_168338,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_168332],"is-function non-empty expression as an argument"]]],['_tail'=_168344,'_head'=_168338,'_type'=_168332],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(795,14),line_char(797,98))). -user:metta_file_buffer(13,296000847,indexed(metta_other,[eval,['if-decons-expr',_168966,_168988,_169010,['if-unify',_168988,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_168966],"is-function non-empty expression as an argument"]]]]),[eval,['if-decons-expr',_169238,_169244,_169250,['if-unify',_169244,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_169238],"is-function non-empty expression as an argument"]]]],['_tail'=_169250,'_head'=_169244,'_type'=_169238],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(795,8),line_char(797,99))). -user:metta_file_buffer(12,296000847,indexed(array,[[_169856,'Expression'],[eval,['if-decons-expr',_169856,_169936,_169958,['if-unify',_169936,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_169856],"is-function non-empty expression as an argument"]]]]]),[[_170174,'Expression'],[eval,['if-decons-expr',_170174,_170210,_170216,['if-unify',_170210,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_170174],"is-function non-empty expression as an argument"]]]]],['_tail'=_170216,'_head'=_170210,'_type'=_170174],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(794,6),line_char(797,100))). -user:metta_file_buffer(14,296000849,variable,_171566,['_type'=_171566],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(798,8),line_char(798,13))). -user:metta_file_buffer(14,296000849,variable,_172858,['_meta'=_172858],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(798,14),line_char(798,19))). -user:metta_file_buffer(13,296000849,indexed(metta_other,[_173684,_173706]),[_173752,_173758],['_meta'=_173758,'_type'=_173752],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(798,7),line_char(798,20))). -user:metta_file_buffer(14,296000850,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(798,22),line_char(798,28))). -user:metta_file_buffer(14,296000850,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(798,29),line_char(798,34))). -user:metta_file_buffer(13,296000850,metta_other,[return,'False'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(798,21),line_char(798,35))). -user:metta_file_buffer(12,296000850,indexed(array,[[_176248,_176270],[return,'False']]),[[_176346,_176352],[return,'False']],['_meta'=_176352,'_type'=_176346],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(798,6),line_char(798,36))). -user:metta_file_buffer(11,296000850,indexed(array,[[[_176910,'Expression'],[eval,['if-decons-expr',_176910,_176990,_177012,['if-unify',_176990,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_176910],"is-function non-empty expression as an argument"]]]]],[[_176910,_177232],[return,'False']]]),[[[_177314,'Expression'],[eval,['if-decons-expr',_177314,_177350,_177356,['if-unify',_177350,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_177314],"is-function non-empty expression as an argument"]]]]],[[_177314,_177440],[return,'False']]],['_meta'=_177440,'_tail'=_177356,'_head'=_177350,'_type'=_177314],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(793,32),line_char(799,5))). -user:metta_file_buffer(10,296000850,indexed(metta_other,[switch,[_178018,_178040],[[[_178018,'Expression'],[eval,['if-decons-expr',_178018,_178162,_178184,['if-unify',_178162,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_178018],"is-function non-empty expression as an argument"]]]]],[[_178018,_178040],[return,'False']]]]),[switch,[_178482,_178488],[[[_178482,'Expression'],[eval,['if-decons-expr',_178482,_178548,_178554,['if-unify',_178548,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_178482],"is-function non-empty expression as an argument"]]]]],[[_178482,_178488],[return,'False']]]],['_tail'=_178554,'_head'=_178548,'_meta'=_178488,'_type'=_178482],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(793,10),line_char(799,6))). -user:metta_file_buffer(9,296000850,indexed(metta_other,[eval,[switch,[_179220,_179242],[[[_179220,'Expression'],[eval,['if-decons-expr',_179220,_179364,_179386,['if-unify',_179364,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_179220],"is-function non-empty expression as an argument"]]]]],[[_179220,_179242],[return,'False']]]]]),[eval,[switch,[_179696,_179702],[[[_179696,'Expression'],[eval,['if-decons-expr',_179696,_179762,_179768,['if-unify',_179762,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_179696],"is-function non-empty expression as an argument"]]]]],[[_179696,_179702],[return,'False']]]]],['_tail'=_179768,'_head'=_179762,'_meta'=_179702,'_type'=_179696],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(793,4),line_char(799,7))). -user:metta_file_buffer(8,296000850,indexed(metta_other,[chain,[eval,['get-metatype',_180454]],_180476,[eval,[switch,[_180454,_180476],[[[_180454,'Expression'],[eval,['if-decons-expr',_180454,_180674,_180696,['if-unify',_180674,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_180454],"is-function non-empty expression as an argument"]]]]],[[_180454,_180476],[return,'False']]]]]]),[chain,[eval,['get-metatype',_181012]],_181018,[eval,[switch,[_181012,_181018],[[[_181012,'Expression'],[eval,['if-decons-expr',_181012,_181120,_181126,['if-unify',_181120,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_181012],"is-function non-empty expression as an argument"]]]]],[[_181012,_181018],[return,'False']]]]]],['_tail'=_181126,'_head'=_181120,'_meta'=_181018,'_type'=_181012],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(792,12),line_char(799,8))). -user:metta_file_buffer(7,296000850,indexed(metta_other,[function,[chain,[eval,['get-metatype',_181816]],_181838,[eval,[switch,[_181816,_181838],[[[_181816,'Expression'],[eval,['if-decons-expr',_181816,_182036,_182058,['if-unify',_182036,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_181816],"is-function non-empty expression as an argument"]]]]],[[_181816,_181838],[return,'False']]]]]]]),[function,[chain,[eval,['get-metatype',_182386]],_182392,[eval,[switch,[_182386,_182392],[[[_182386,'Expression'],[eval,['if-decons-expr',_182386,_182494,_182500,['if-unify',_182494,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_182386],"is-function non-empty expression as an argument"]]]]],[[_182386,_182392],[return,'False']]]]]]],['_tail'=_182500,'_head'=_182494,'_meta'=_182392,'_type'=_182386],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(792,2),line_char(799,9))). -user:metta_file_buffer(6,296000850,indexed(metta_defun,['is-function',_183164]),[=,['is-function',_183792],[function,[chain,[eval,['get-metatype',_183792]],_183852,[eval,[switch,[_183792,_183852],[[[_183792,'Expression'],[eval,['if-decons-expr',_183792,_183954,_183960,['if-unify',_183954,->,[return,'True'],[return,'False']],[return,['Error',['is-function',_183792],"is-function non-empty expression as an argument"]]]]],[[_183792,_183852],[return,'False']]]]]]]],['_tail'=_183960,'_head'=_183954,'_meta'=_183852,'_type'=_183792],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(791,0),line_char(799,10))). -user:metta_file_buffer(7,297000851,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(801,1),line_char(801,3))). -user:metta_file_buffer(7,297000851,constant,'type-cast',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(801,4),line_char(801,13))). -user:metta_file_buffer(7,297000851,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(801,14),line_char(801,19))). -user:metta_file_buffer(6,297000851,metta_other,[iz,'type-cast','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(801,0),line_char(801,20))). -user:metta_file_buffer(7,298000852,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(802,1),line_char(802,5))). -user:metta_file_buffer(7,298000852,constant,'type-cast',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(802,6),line_char(802,15))). -user:metta_file_buffer(8,298000853,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(803,3),line_char(803,8))). -user:metta_file_buffer(8,298000853,string,"Casts atom passed as a first argument to the type passed as a second argument using space as a context",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(803,9),line_char(803,113))). -user:metta_file_buffer(7,298000853,metta_other,['@desc',"Casts atom passed as a first argument to the type passed as a second argument using space as a context"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(803,2),line_char(803,114))). -user:metta_file_buffer(8,298000854,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(804,3),line_char(804,10))). -user:metta_file_buffer(10,298000856,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(805,5),line_char(805,11))). -user:metta_file_buffer(10,298000856,string,"Atom to be casted",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(805,12),line_char(805,31))). -user:metta_file_buffer(9,298000856,metta_other,['@param',"Atom to be casted"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(805,4),line_char(805,32))). -user:metta_file_buffer(10,298000857,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(806,5),line_char(806,11))). -user:metta_file_buffer(10,298000857,string,"Type to cast atom to",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(806,12),line_char(806,34))). -user:metta_file_buffer(9,298000857,metta_other,['@param',"Type to cast atom to"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(806,4),line_char(806,35))). -user:metta_file_buffer(10,298000858,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(807,5),line_char(807,11))). -user:metta_file_buffer(10,298000858,string,"Context atomspace",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(807,12),line_char(807,31))). -user:metta_file_buffer(9,298000858,metta_other,['@param',"Context atomspace"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(807,4),line_char(807,32))). -user:metta_file_buffer(8,298000858,array,[['@param',"Atom to be casted"],['@param',"Type to cast atom to"],['@param',"Context atomspace"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(804,11),line_char(807,33))). -user:metta_file_buffer(7,298000858,metta_other,['@params',[['@param',"Atom to be casted"],['@param',"Type to cast atom to"],['@param',"Context atomspace"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(804,2),line_char(807,34))). -user:metta_file_buffer(8,298000859,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(808,3),line_char(808,10))). -user:metta_file_buffer(8,298000859,string,"Atom if casting is successful, (Error ... BadType) otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(808,11),line_char(808,73))). -user:metta_file_buffer(7,298000859,metta_other,['@return',"Atom if casting is successful, (Error ... BadType) otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(808,2),line_char(808,74))). -user:metta_file_buffer(6,298000859,metta_other,['@doc','type-cast',['@desc',"Casts atom passed as a first argument to the type passed as a second argument using space as a context"],['@params',[['@param',"Atom to be casted"],['@param',"Type to cast atom to"],['@param',"Context atomspace"]]],['@return',"Atom if casting is successful, (Error ... BadType) otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(802,0),line_char(808,75))). -user:metta_file_buffer(7,299000860,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(809,1),line_char(809,2))). -user:metta_file_buffer(7,299000860,constant,'type-cast',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(809,3),line_char(809,12))). -user:metta_file_buffer(8,299000861,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(809,14),line_char(809,16))). -user:metta_file_buffer(8,299000861,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(809,17),line_char(809,21))). -user:metta_file_buffer(8,299000861,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(809,22),line_char(809,26))). -user:metta_file_buffer(8,299000861,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(809,27),line_char(809,31))). -user:metta_file_buffer(8,299000861,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(809,32),line_char(809,36))). -user:metta_file_buffer(7,299000861,metta_other,[->,'Atom','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(809,13),line_char(809,37))). -user:metta_file_buffer(6,299000861,metta_typedecl,[:,'type-cast',[->,'Atom','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(809,0),line_char(809,38))). -user:metta_file_buffer(6,300000861,indexed(metta_comment,";; This implementation is old and may not be sufficient."),'$COMMENT'(";; This implementation is old and may not be sufficient.",810,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(810,0),line_char(810,56))). -user:metta_file_buffer(7,300000862,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(811,1),line_char(811,5))). -user:metta_file_buffer(8,300000863,constant,'type-cast',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(811,7),line_char(811,16))). -user:metta_file_buffer(8,300000863,variable,_132838,['_atom'=_132838],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(811,17),line_char(811,22))). -user:metta_file_buffer(8,300000863,variable,_134122,['_type'=_134122],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(811,23),line_char(811,28))). -user:metta_file_buffer(8,300000863,variable,_135430,['_space'=_135430],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(811,29),line_char(811,35))). -user:metta_file_buffer(7,300000863,indexed(metta_other,['type-cast',_136276,_136298,_136320]),['type-cast',_136372,_136378,_136384],['_space'=_136384,'_type'=_136378,'_atom'=_136372],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(811,6),line_char(811,36))). -user:metta_file_buffer(8,300000864,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(812,3),line_char(812,11))). -user:metta_file_buffer(9,300000865,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(812,13),line_char(812,18))). -user:metta_file_buffer(10,300000866,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(812,20),line_char(812,24))). -user:metta_file_buffer(11,300000867,constant,'get-metatype',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(812,26),line_char(812,38))). -user:metta_file_buffer(11,300000867,variable,_140630,['_atom'=_140630],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(812,39),line_char(812,44))). -user:metta_file_buffer(10,300000867,indexed(metta_other,['get-metatype',_141464]),['get-metatype',_141516],['_atom'=_141516],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(812,25),line_char(812,45))). -user:metta_file_buffer(9,300000867,indexed(metta_other,[eval,['get-metatype',_142054]]),[eval,['get-metatype',_142118]],['_atom'=_142118],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(812,19),line_char(812,46))). -user:metta_file_buffer(9,300000867,variable,_143090,['_meta'=_143090],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(812,47),line_char(812,52))). -user:metta_file_buffer(10,300000868,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(813,5),line_char(813,9))). -user:metta_file_buffer(11,300000869,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(813,11),line_char(813,19))). -user:metta_file_buffer(11,300000869,variable,_145942,['_type'=_145942],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(813,20),line_char(813,25))). -user:metta_file_buffer(11,300000869,variable,_147226,['_meta'=_147226],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(813,26),line_char(813,31))). -user:metta_file_buffer(12,300000870,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(814,7),line_char(814,13))). -user:metta_file_buffer(12,300000870,variable,_149344,['_atom'=_149344],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(814,14),line_char(814,19))). -user:metta_file_buffer(11,300000870,indexed(metta_other,[return,_150178]),[return,_150230],['_atom'=_150230],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(814,6),line_char(814,20))). -user:metta_file_buffer(12,300000871,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,7),line_char(815,12))). -user:metta_file_buffer(13,300000872,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,14),line_char(815,18))). -user:metta_file_buffer(14,300000873,constant,'collapse-bind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,20),line_char(815,33))). -user:metta_file_buffer(15,300000874,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,35),line_char(815,39))). -user:metta_file_buffer(16,300000875,constant,'get-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,41),line_char(815,49))). -user:metta_file_buffer(16,300000875,variable,_155188,['_atom'=_155188],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,50),line_char(815,55))). -user:metta_file_buffer(16,300000875,variable,_156496,['_space'=_156496],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,56),line_char(815,62))). -user:metta_file_buffer(15,300000875,indexed(metta_other,['get-type',_157336,_157358]),['get-type',_157410,_157416],['_space'=_157416,'_atom'=_157410],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,40),line_char(815,63))). -user:metta_file_buffer(14,300000875,indexed(metta_other,[eval,['get-type',_157966,_157988]]),[eval,['get-type',_158052,_158058]],['_space'=_158058,'_atom'=_158052],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,34),line_char(815,64))). -user:metta_file_buffer(13,300000875,indexed(metta_other,['collapse-bind',[eval,['get-type',_158624,_158646]]]),['collapse-bind',[eval,['get-type',_158722,_158728]]],['_space'=_158728,'_atom'=_158722],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,19),line_char(815,65))). -user:metta_file_buffer(12,300000875,indexed(metta_other,[eval,['collapse-bind',[eval,['get-type',_159310,_159332]]]]),[eval,['collapse-bind',[eval,['get-type',_159420,_159426]]]],['_space'=_159426,'_atom'=_159420],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,13),line_char(815,66))). -user:metta_file_buffer(12,300000875,variable,_160506,['_collapsed'=_160506],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,67),line_char(815,77))). -user:metta_file_buffer(13,300000876,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,9),line_char(816,14))). -user:metta_file_buffer(14,300000877,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,16),line_char(816,20))). -user:metta_file_buffer(15,300000878,constant,'map-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,22),line_char(816,30))). -user:metta_file_buffer(15,300000878,variable,_164266,['_collapsed'=_164266],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,31),line_char(816,41))). -user:metta_file_buffer(15,300000878,variable,_165550,['_pair'=_165550],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,42),line_char(816,47))). -user:metta_file_buffer(16,300000879,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,49),line_char(816,53))). -user:metta_file_buffer(17,300000880,constant,'first-from-pair',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,55),line_char(816,70))). -user:metta_file_buffer(17,300000880,variable,_168472,['_pair'=_168472],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,71),line_char(816,76))). -user:metta_file_buffer(16,300000880,indexed(metta_other,['first-from-pair',_169306]),['first-from-pair',_169358],['_pair'=_169358],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,54),line_char(816,77))). -user:metta_file_buffer(15,300000880,indexed(metta_other,[eval,['first-from-pair',_169896]]),[eval,['first-from-pair',_169960]],['_pair'=_169960],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,48),line_char(816,78))). -user:metta_file_buffer(14,300000880,indexed(metta_other,['map-atom',_170494,_170516,[eval,['first-from-pair',_170516]]]),['map-atom',_170618,_170624,[eval,['first-from-pair',_170624]]],['_pair'=_170624,'_collapsed'=_170618],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,21),line_char(816,79))). -user:metta_file_buffer(13,300000880,indexed(metta_other,[eval,['map-atom',_171204,_171226,[eval,['first-from-pair',_171226]]]]),[eval,['map-atom',_171340,_171346,[eval,['first-from-pair',_171346]]]],['_pair'=_171346,'_collapsed'=_171340],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,15),line_char(816,80))). -user:metta_file_buffer(13,300000880,variable,_172510,['_actual_types'=_172510],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,81),line_char(816,94))). -user:metta_file_buffer(14,300000881,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,13),line_char(817,18))). -user:metta_file_buffer(15,300000882,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,20),line_char(817,24))). -user:metta_file_buffer(16,300000883,constant,'foldl-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,26),line_char(817,36))). -user:metta_file_buffer(16,300000883,variable,_176352,['_actual_types'=_176352],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,37),line_char(817,50))). -user:metta_file_buffer(16,300000883,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,51),line_char(817,56))). -user:metta_file_buffer(16,300000883,variable,_178186,['_a'=_178186],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,57),line_char(817,59))). -user:metta_file_buffer(16,300000883,variable,_179422,['_b'=_179422],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,60),line_char(817,62))). -user:metta_file_buffer(17,300000884,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,64),line_char(817,68))). -user:metta_file_buffer(18,300000885,constant,'match-type-or',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,70),line_char(817,83))). -user:metta_file_buffer(18,300000885,variable,_182268,['_a'=_182268],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,84),line_char(817,86))). -user:metta_file_buffer(18,300000885,variable,_183504,['_b'=_183504],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,87),line_char(817,89))). -user:metta_file_buffer(18,300000885,variable,_184796,['_type'=_184796],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,90),line_char(817,95))). -user:metta_file_buffer(17,300000885,indexed(metta_other,['match-type-or',_185642,_185664,_185686]),['match-type-or',_185738,_185744,_185750],['_type'=_185750,'_b'=_185744,'_a'=_185738],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,69),line_char(817,96))). -user:metta_file_buffer(16,300000885,indexed(metta_other,[eval,['match-type-or',_186312,_186334,_186356]]),[eval,['match-type-or',_186420,_186426,_186432]],['_type'=_186432,'_b'=_186426,'_a'=_186420],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,63),line_char(817,97))). -user:metta_file_buffer(15,300000885,indexed(metta_other,['foldl-atom',_187002,'False',_187032,_187054,[eval,['match-type-or',_187032,_187054,_187144]]]),['foldl-atom',_187196,'False',_187208,_187214,[eval,['match-type-or',_187208,_187214,_187256]]],['_type'=_187256,'_b'=_187214,'_a'=_187208,'_actual_types'=_187196],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,25),line_char(817,98))). -user:metta_file_buffer(14,300000885,indexed(metta_other,[eval,['foldl-atom',_187830,'False',_187860,_187882,[eval,['match-type-or',_187860,_187882,_187972]]]]),[eval,['foldl-atom',_188036,'False',_188048,_188054,[eval,['match-type-or',_188048,_188054,_188096]]]],['_type'=_188096,'_b'=_188054,'_a'=_188048,'_actual_types'=_188036],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,19),line_char(817,99))). -user:metta_file_buffer(14,300000885,variable,_189260,['_is_some_comp'=_189260],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,100),line_char(817,113))). -user:metta_file_buffer(15,300000886,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(818,15),line_char(818,19))). -user:metta_file_buffer(16,300000887,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(818,21),line_char(818,23))). -user:metta_file_buffer(16,300000887,variable,_192296,['_is_some_comp'=_192296],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(818,24),line_char(818,37))). -user:metta_file_buffer(17,300000888,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(819,17),line_char(819,23))). -user:metta_file_buffer(17,300000888,variable,_194434,['_atom'=_194434],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(819,24),line_char(819,29))). -user:metta_file_buffer(16,300000888,indexed(metta_other,[return,_195268]),[return,_195320],['_atom'=_195320],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(819,16),line_char(819,30))). -user:metta_file_buffer(17,300000889,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(820,17),line_char(820,23))). -user:metta_file_buffer(18,300000890,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(820,25),line_char(820,30))). -user:metta_file_buffer(18,300000890,variable,_197874,['_atom'=_197874],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(820,31),line_char(820,36))). -user:metta_file_buffer(18,300000890,constant,'BadType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(820,37),line_char(820,44))). -user:metta_file_buffer(17,300000890,indexed(metta_other,['Error',_199340,'BadType']),['Error',_199400,'BadType'],['_atom'=_199400],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(820,24),line_char(820,45))). -user:metta_file_buffer(16,300000890,indexed(metta_other,[return,['Error',_199938,'BadType']]),[return,['Error',_200010,'BadType']],['_atom'=_200010],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(820,16),line_char(820,46))). -user:metta_file_buffer(15,300000890,indexed(metta_other,[if,_200546,[return,_200584],[return,['Error',_200584,'BadType']]]),[if,_200694,[return,_200712],[return,['Error',_200712,'BadType']]],['_atom'=_200712,'_is_some_comp'=_200694],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(818,20),line_char(820,48))). -user:metta_file_buffer(14,300000890,indexed(metta_other,[eval,[if,_201292,[return,_201330],[return,['Error',_201330,'BadType']]]]),[eval,[if,_201452,[return,_201470],[return,['Error',_201470,'BadType']]]],['_atom'=_201470,'_is_some_comp'=_201452],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(818,14),line_char(820,49))). -user:metta_file_buffer(13,300000890,indexed(metta_other,[chain,[eval,['foldl-atom',_202078,'False',_202108,_202130,[eval,['match-type-or',_202108,_202130,_202220]]]],_202242,[eval,[if,_202242,[return,_202330],[return,['Error',_202330,'BadType']]]]]),[chain,[eval,['foldl-atom',_202464,'False',_202476,_202482,[eval,['match-type-or',_202476,_202482,_202524]]]],_202530,[eval,[if,_202530,[return,_202578],[return,['Error',_202578,'BadType']]]]],['_atom'=_202578,'_is_some_comp'=_202530,'_type'=_202524,'_b'=_202482,'_a'=_202476,'_actual_types'=_202464],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(817,12),line_char(820,50))). -user:metta_file_buffer(12,300000890,indexed(metta_other,[chain,[eval,['map-atom',_203234,_203256,[eval,['first-from-pair',_203256]]]],_203328,[chain,[eval,['foldl-atom',_203328,'False',_203424,_203446,[eval,['match-type-or',_203424,_203446,_203536]]]],_203558,[eval,[if,_203558,[return,_203646],[return,['Error',_203646,'BadType']]]]]]),[chain,[eval,['map-atom',_203780,_203786,[eval,['first-from-pair',_203786]]]],_203822,[chain,[eval,['foldl-atom',_203822,'False',_203876,_203882,[eval,['match-type-or',_203876,_203882,_203924]]]],_203930,[eval,[if,_203930,[return,_203978],[return,['Error',_203978,'BadType']]]]]],['_atom'=_203978,'_is_some_comp'=_203930,'_type'=_203924,'_b'=_203882,'_a'=_203876,'_actual_types'=_203822,'_pair'=_203786,'_collapsed'=_203780],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(816,8),line_char(820,51))). -user:metta_file_buffer(11,300000890,indexed(metta_other,[chain,[eval,['collapse-bind',[eval,['get-type',_204690,_204712]]]],_204734,[chain,[eval,['map-atom',_204734,_204822,[eval,['first-from-pair',_204822]]]],_204894,[chain,[eval,['foldl-atom',_204894,'False',_204990,_205012,[eval,['match-type-or',_204990,_205012,_205102]]]],_205124,[eval,[if,_205124,[return,_204690],[return,['Error',_204690,'BadType']]]]]]]),[chain,[eval,['collapse-bind',[eval,['get-type',_205366,_205372]]]],_205378,[chain,[eval,['map-atom',_205378,_205426,[eval,['first-from-pair',_205426]]]],_205462,[chain,[eval,['foldl-atom',_205462,'False',_205516,_205522,[eval,['match-type-or',_205516,_205522,_205564]]]],_205570,[eval,[if,_205570,[return,_205366],[return,['Error',_205366,'BadType']]]]]]],['_is_some_comp'=_205570,'_type'=_205564,'_b'=_205522,'_a'=_205516,'_actual_types'=_205462,'_pair'=_205426,'_collapsed'=_205378,'_space'=_205372,'_atom'=_205366],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(815,6),line_char(820,52))). -user:metta_file_buffer(10,300000890,indexed(metta_other,['if-equal',_206284,_206306,[return,_206344],[chain,[eval,['collapse-bind',[eval,['get-type',_206344,_206464]]]],_206486,[chain,[eval,['map-atom',_206486,_206574,[eval,['first-from-pair',_206574]]]],_206646,[chain,[eval,['foldl-atom',_206646,'False',_206742,_206764,[eval,['match-type-or',_206742,_206764,_206284]]]],_206872,[eval,[if,_206872,[return,_206344],[return,['Error',_206344,'BadType']]]]]]]]),['if-equal',_207066,_207072,[return,_207090],[chain,[eval,['collapse-bind',[eval,['get-type',_207090,_207162]]]],_207168,[chain,[eval,['map-atom',_207168,_207216,[eval,['first-from-pair',_207216]]]],_207252,[chain,[eval,['foldl-atom',_207252,'False',_207306,_207312,[eval,['match-type-or',_207306,_207312,_207066]]]],_207360,[eval,[if,_207360,[return,_207090],[return,['Error',_207090,'BadType']]]]]]]],['_is_some_comp'=_207360,'_b'=_207312,'_a'=_207306,'_actual_types'=_207252,'_pair'=_207216,'_collapsed'=_207168,'_space'=_207162,'_atom'=_207090,'_meta'=_207072,'_type'=_207066],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(813,10),line_char(820,53))). -user:metta_file_buffer(9,300000890,indexed(metta_other,[eval,['if-equal',_208084,_208106,[return,_208144],[chain,[eval,['collapse-bind',[eval,['get-type',_208144,_208264]]]],_208286,[chain,[eval,['map-atom',_208286,_208374,[eval,['first-from-pair',_208374]]]],_208446,[chain,[eval,['foldl-atom',_208446,'False',_208542,_208564,[eval,['match-type-or',_208542,_208564,_208084]]]],_208672,[eval,[if,_208672,[return,_208144],[return,['Error',_208144,'BadType']]]]]]]]]),[eval,['if-equal',_208878,_208884,[return,_208902],[chain,[eval,['collapse-bind',[eval,['get-type',_208902,_208974]]]],_208980,[chain,[eval,['map-atom',_208980,_209028,[eval,['first-from-pair',_209028]]]],_209064,[chain,[eval,['foldl-atom',_209064,'False',_209118,_209124,[eval,['match-type-or',_209118,_209124,_208878]]]],_209172,[eval,[if,_209172,[return,_208902],[return,['Error',_208902,'BadType']]]]]]]]],['_is_some_comp'=_209172,'_b'=_209124,'_a'=_209118,'_actual_types'=_209064,'_pair'=_209028,'_collapsed'=_208980,'_space'=_208974,'_atom'=_208902,'_meta'=_208884,'_type'=_208878],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(813,4),line_char(820,54))). -user:metta_file_buffer(8,300000890,indexed(metta_other,[chain,[eval,['get-metatype',_209924]],_209946,[eval,['if-equal',_210000,_209946,[return,_209924],[chain,[eval,['collapse-bind',[eval,['get-type',_209924,_210172]]]],_210194,[chain,[eval,['map-atom',_210194,_210282,[eval,['first-from-pair',_210282]]]],_210354,[chain,[eval,['foldl-atom',_210354,'False',_210450,_210472,[eval,['match-type-or',_210450,_210472,_210000]]]],_210580,[eval,[if,_210580,[return,_209924],[return,['Error',_209924,'BadType']]]]]]]]]]),[chain,[eval,['get-metatype',_210798]],_210804,[eval,['if-equal',_210834,_210804,[return,_210798],[chain,[eval,['collapse-bind',[eval,['get-type',_210798,_210930]]]],_210936,[chain,[eval,['map-atom',_210936,_210984,[eval,['first-from-pair',_210984]]]],_211020,[chain,[eval,['foldl-atom',_211020,'False',_211074,_211080,[eval,['match-type-or',_211074,_211080,_210834]]]],_211128,[eval,[if,_211128,[return,_210798],[return,['Error',_210798,'BadType']]]]]]]]]],['_is_some_comp'=_211128,'_b'=_211080,'_a'=_211074,'_actual_types'=_211020,'_pair'=_210984,'_collapsed'=_210936,'_space'=_210930,'_type'=_210834,'_meta'=_210804,'_atom'=_210798],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(812,12),line_char(820,55))). -user:metta_file_buffer(7,300000890,indexed(metta_other,[function,[chain,[eval,['get-metatype',_211884]],_211906,[eval,['if-equal',_211960,_211906,[return,_211884],[chain,[eval,['collapse-bind',[eval,['get-type',_211884,_212132]]]],_212154,[chain,[eval,['map-atom',_212154,_212242,[eval,['first-from-pair',_212242]]]],_212314,[chain,[eval,['foldl-atom',_212314,'False',_212410,_212432,[eval,['match-type-or',_212410,_212432,_211960]]]],_212540,[eval,[if,_212540,[return,_211884],[return,['Error',_211884,'BadType']]]]]]]]]]]),[function,[chain,[eval,['get-metatype',_212770]],_212776,[eval,['if-equal',_212806,_212776,[return,_212770],[chain,[eval,['collapse-bind',[eval,['get-type',_212770,_212902]]]],_212908,[chain,[eval,['map-atom',_212908,_212956,[eval,['first-from-pair',_212956]]]],_212992,[chain,[eval,['foldl-atom',_212992,'False',_213046,_213052,[eval,['match-type-or',_213046,_213052,_212806]]]],_213100,[eval,[if,_213100,[return,_212770],[return,['Error',_212770,'BadType']]]]]]]]]]],['_is_some_comp'=_213100,'_b'=_213052,'_a'=_213046,'_actual_types'=_212992,'_pair'=_212956,'_collapsed'=_212908,'_space'=_212902,'_type'=_212806,'_meta'=_212776,'_atom'=_212770],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(812,2),line_char(820,56))). -user:metta_file_buffer(6,300000890,indexed(metta_other,['ALT=',['type-cast',_213830,_213852,_213874],[function,[chain,[eval,['get-metatype',_213830]],_213978,[eval,['if-equal',_213852,_213978,[return,_213830],[chain,[eval,['collapse-bind',[eval,['get-type',_213830,_213874]]]],_214218,[chain,[eval,['map-atom',_214218,_214306,[eval,['first-from-pair',_214306]]]],_214378,[chain,[eval,['foldl-atom',_214378,'False',_214474,_214496,[eval,['match-type-or',_214474,_214496,_213852]]]],_214604,[eval,[if,_214604,[return,_213830],[return,['Error',_213830,'BadType']]]]]]]]]]]]),['ALT=',['type-cast',_214810,_214816,_214822],[function,[chain,[eval,['get-metatype',_214810]],_214882,[eval,['if-equal',_214816,_214882,[return,_214810],[chain,[eval,['collapse-bind',[eval,['get-type',_214810,_214822]]]],_215014,[chain,[eval,['map-atom',_215014,_215062,[eval,['first-from-pair',_215062]]]],_215098,[chain,[eval,['foldl-atom',_215098,'False',_215152,_215158,[eval,['match-type-or',_215152,_215158,_214816]]]],_215206,[eval,[if,_215206,[return,_214810],[return,['Error',_214810,'BadType']]]]]]]]]]]],['_is_some_comp'=_215206,'_b'=_215158,'_a'=_215152,'_actual_types'=_215098,'_pair'=_215062,'_collapsed'=_215014,'_meta'=_214882,'_space'=_214822,'_type'=_214816,'_atom'=_214810],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(811,0),line_char(820,57))). -user:metta_file_buffer(7,301000891,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(822,1),line_char(822,3))). -user:metta_file_buffer(7,301000891,constant,'match-types',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(822,4),line_char(822,15))). -user:metta_file_buffer(7,301000891,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(822,16),line_char(822,21))). -user:metta_file_buffer(6,301000891,metta_other,[iz,'match-types','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(822,0),line_char(822,22))). -user:metta_file_buffer(7,302000892,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(823,1),line_char(823,5))). -user:metta_file_buffer(7,302000892,constant,'match-types',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(823,6),line_char(823,17))). -user:metta_file_buffer(8,302000893,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(824,3),line_char(824,8))). -user:metta_file_buffer(8,302000893,string,"Checks if two types can be unified and returns third argument if so, fourth - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(824,9),line_char(824,98))). -user:metta_file_buffer(7,302000893,metta_other,['@desc',"Checks if two types can be unified and returns third argument if so, fourth - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(824,2),line_char(824,99))). -user:metta_file_buffer(8,302000894,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(825,3),line_char(825,10))). -user:metta_file_buffer(10,302000896,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(826,5),line_char(826,11))). -user:metta_file_buffer(10,302000896,string,"First type",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(826,12),line_char(826,24))). -user:metta_file_buffer(9,302000896,metta_other,['@param',"First type"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(826,4),line_char(826,25))). -user:metta_file_buffer(10,302000897,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(827,5),line_char(827,11))). -user:metta_file_buffer(10,302000897,string,"Second type",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(827,12),line_char(827,25))). -user:metta_file_buffer(9,302000897,metta_other,['@param',"Second type"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(827,4),line_char(827,26))). -user:metta_file_buffer(10,302000898,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(828,5),line_char(828,11))). -user:metta_file_buffer(10,302000898,string,"Atom to be returned if types can be unified",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(828,12),line_char(828,57))). -user:metta_file_buffer(9,302000898,metta_other,['@param',"Atom to be returned if types can be unified"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(828,4),line_char(828,58))). -user:metta_file_buffer(10,302000899,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(829,5),line_char(829,11))). -user:metta_file_buffer(10,302000899,string,"Atom to be returned if types cannot be unified",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(829,12),line_char(829,60))). -user:metta_file_buffer(9,302000899,metta_other,['@param',"Atom to be returned if types cannot be unified"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(829,4),line_char(829,61))). -user:metta_file_buffer(8,302000899,array,[['@param',"First type"],['@param',"Second type"],['@param',"Atom to be returned if types can be unified"],['@param',"Atom to be returned if types cannot be unified"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(825,11),line_char(829,62))). -user:metta_file_buffer(7,302000899,metta_other,['@params',[['@param',"First type"],['@param',"Second type"],['@param',"Atom to be returned if types can be unified"],['@param',"Atom to be returned if types cannot be unified"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(825,2),line_char(829,63))). -user:metta_file_buffer(8,302000900,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(830,3),line_char(830,10))). -user:metta_file_buffer(8,302000900,string,"Third or fourth argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(830,11),line_char(830,37))). -user:metta_file_buffer(7,302000900,metta_other,['@return',"Third or fourth argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(830,2),line_char(830,38))). -user:metta_file_buffer(6,302000900,metta_other,['@doc','match-types',['@desc',"Checks if two types can be unified and returns third argument if so, fourth - otherwise"],['@params',[['@param',"First type"],['@param',"Second type"],['@param',"Atom to be returned if types can be unified"],['@param',"Atom to be returned if types cannot be unified"]]],['@return',"Third or fourth argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(823,0),line_char(830,39))). -user:metta_file_buffer(7,303000901,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(831,1),line_char(831,2))). -user:metta_file_buffer(7,303000901,constant,'match-types',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(831,3),line_char(831,14))). -user:metta_file_buffer(8,303000902,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(831,16),line_char(831,18))). -user:metta_file_buffer(8,303000902,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(831,19),line_char(831,23))). -user:metta_file_buffer(8,303000902,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(831,24),line_char(831,28))). -user:metta_file_buffer(8,303000902,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(831,29),line_char(831,33))). -user:metta_file_buffer(8,303000902,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(831,34),line_char(831,38))). -user:metta_file_buffer(8,303000902,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(831,39),line_char(831,43))). -user:metta_file_buffer(7,303000902,metta_other,[->,'Atom','Atom','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(831,15),line_char(831,44))). -user:metta_file_buffer(6,303000902,metta_typedecl,[:,'match-types',[->,'Atom','Atom','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(831,0),line_char(831,45))). -user:metta_file_buffer(7,304000903,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(832,1),line_char(832,2))). -user:metta_file_buffer(8,304000904,constant,'match-types',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(832,4),line_char(832,15))). -user:metta_file_buffer(8,304000904,variable,_133286,['_type1'=_133286],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(832,16),line_char(832,22))). -user:metta_file_buffer(8,304000904,variable,_134586,['_type2'=_134586],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(832,23),line_char(832,29))). -user:metta_file_buffer(8,304000904,variable,_135870,['_then'=_135870],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(832,30),line_char(832,35))). -user:metta_file_buffer(8,304000904,variable,_137162,['_else'=_137162],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(832,36),line_char(832,41))). -user:metta_file_buffer(7,304000904,indexed(metta_other,['match-types',_138014,_138036,_138058,_138080]),['match-types',_138132,_138138,_138144,_138150],['_else'=_138150,'_then'=_138144,'_type2'=_138138,'_type1'=_138132],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(832,3),line_char(832,42))). -user:metta_file_buffer(8,304000905,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(833,3),line_char(833,11))). -user:metta_file_buffer(9,304000906,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(833,13),line_char(833,17))). -user:metta_file_buffer(10,304000907,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(833,19),line_char(833,27))). -user:metta_file_buffer(10,304000907,variable,_141572,['_type1'=_141572],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(833,28),line_char(833,34))). -user:metta_file_buffer(10,304000907,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(833,35),line_char(833,46))). -user:metta_file_buffer(11,304000908,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(834,5),line_char(834,11))). -user:metta_file_buffer(11,304000908,variable,_144452,['_then'=_144452],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(834,12),line_char(834,17))). -user:metta_file_buffer(10,304000908,indexed(metta_other,[return,_145286]),[return,_145338],['_then'=_145338],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(834,4),line_char(834,18))). -user:metta_file_buffer(11,304000909,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(835,5),line_char(835,9))). -user:metta_file_buffer(12,304000910,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(835,11),line_char(835,19))). -user:metta_file_buffer(12,304000910,variable,_147894,['_type2'=_147894],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(835,20),line_char(835,26))). -user:metta_file_buffer(12,304000910,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(835,27),line_char(835,38))). -user:metta_file_buffer(13,304000911,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(836,7),line_char(836,13))). -user:metta_file_buffer(13,304000911,variable,_150778,['_then'=_150778],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(836,14),line_char(836,19))). -user:metta_file_buffer(12,304000911,indexed(metta_other,[return,_151612]),[return,_151664],['_then'=_151664],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(836,6),line_char(836,20))). -user:metta_file_buffer(13,304000912,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(837,7),line_char(837,11))). -user:metta_file_buffer(14,304000913,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(837,13),line_char(837,21))). -user:metta_file_buffer(14,304000913,variable,_154224,['_type1'=_154224],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(837,22),line_char(837,28))). -user:metta_file_buffer(14,304000913,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(837,29),line_char(837,33))). -user:metta_file_buffer(15,304000914,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(838,9),line_char(838,15))). -user:metta_file_buffer(15,304000914,variable,_156934,['_then'=_156934],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(838,16),line_char(838,21))). -user:metta_file_buffer(14,304000914,indexed(metta_other,[return,_157768]),[return,_157820],['_then'=_157820],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(838,8),line_char(838,22))). -user:metta_file_buffer(15,304000915,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(839,9),line_char(839,13))). -user:metta_file_buffer(16,304000916,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(839,15),line_char(839,23))). -user:metta_file_buffer(16,304000916,variable,_160384,['_type2'=_160384],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(839,24),line_char(839,30))). -user:metta_file_buffer(16,304000916,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(839,31),line_char(839,35))). -user:metta_file_buffer(17,304000917,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(840,11),line_char(840,17))). -user:metta_file_buffer(17,304000917,variable,_163098,['_then'=_163098],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(840,18),line_char(840,23))). -user:metta_file_buffer(16,304000917,indexed(metta_other,[return,_163932]),[return,_163984],['_then'=_163984],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(840,10),line_char(840,24))). -user:metta_file_buffer(17,304000918,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(841,11),line_char(841,19))). -user:metta_file_buffer(17,304000918,variable,_165758,['_type1'=_165758],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(841,20),line_char(841,26))). -user:metta_file_buffer(17,304000918,variable,_167058,['_type2'=_167058],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(841,27),line_char(841,33))). -user:metta_file_buffer(18,304000919,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(841,35),line_char(841,41))). -user:metta_file_buffer(18,304000919,variable,_169164,['_then'=_169164],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(841,42),line_char(841,47))). -user:metta_file_buffer(17,304000919,indexed(metta_other,[return,_169998]),[return,_170050],['_then'=_170050],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(841,34),line_char(841,48))). -user:metta_file_buffer(18,304000920,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(841,50),line_char(841,56))). -user:metta_file_buffer(18,304000920,variable,_171844,['_else'=_171844],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(841,57),line_char(841,62))). -user:metta_file_buffer(17,304000920,indexed(metta_other,[return,_172678]),[return,_172730],['_else'=_172730],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(841,49),line_char(841,63))). -user:metta_file_buffer(16,304000920,indexed(metta_other,['if-unify',_173270,_173292,[return,_173330],[return,_173368]]),['if-unify',_173420,_173426,[return,_173444],[return,_173462]],['_else'=_173462,'_then'=_173444,'_type2'=_173426,'_type1'=_173420],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(841,10),line_char(841,64))). -user:metta_file_buffer(15,304000920,indexed(metta_other,['if-equal',_174040,'Atom',[return,_174086],['if-unify',_174124,_174040,[return,_174086],[return,_174214]]]),['if-equal',_174266,'Atom',[return,_174290],['if-unify',_174308,_174266,[return,_174290],[return,_174350]]],['_else'=_174350,'_type1'=_174308,'_then'=_174290,'_type2'=_174266],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(839,14),line_char(841,66))). -user:metta_file_buffer(14,304000920,indexed(metta_other,[eval,['if-equal',_174924,'Atom',[return,_174970],['if-unify',_175008,_174924,[return,_174970],[return,_175098]]]]),[eval,['if-equal',_175162,'Atom',[return,_175186],['if-unify',_175204,_175162,[return,_175186],[return,_175246]]]],['_else'=_175246,'_type1'=_175204,'_then'=_175186,'_type2'=_175162],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(839,8),line_char(841,67))). -user:metta_file_buffer(13,304000920,indexed(metta_other,['if-equal',_175822,'Atom',[return,_175868],[eval,['if-equal',_175922,'Atom',[return,_175868],['if-unify',_175822,_175922,[return,_175868],[return,_176088]]]]]),['if-equal',_176140,'Atom',[return,_176164],[eval,['if-equal',_176194,'Atom',[return,_176164],['if-unify',_176140,_176194,[return,_176164],[return,_176278]]]]],['_else'=_176278,'_type2'=_176194,'_then'=_176164,'_type1'=_176140],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(837,12),line_char(841,68))). -user:metta_file_buffer(12,304000920,indexed(metta_other,[eval,['if-equal',_176852,'Atom',[return,_176898],[eval,['if-equal',_176952,'Atom',[return,_176898],['if-unify',_176852,_176952,[return,_176898],[return,_177118]]]]]]),[eval,['if-equal',_177182,'Atom',[return,_177206],[eval,['if-equal',_177236,'Atom',[return,_177206],['if-unify',_177182,_177236,[return,_177206],[return,_177320]]]]]],['_else'=_177320,'_type2'=_177236,'_then'=_177206,'_type1'=_177182],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(837,6),line_char(841,69))). -user:metta_file_buffer(11,304000920,indexed(metta_other,['if-equal',_177896,'%Undefined%',[return,_177942],[eval,['if-equal',_177996,'Atom',[return,_177942],[eval,['if-equal',_177896,'Atom',[return,_177942],['if-unify',_177996,_177896,[return,_177942],[return,_178254]]]]]]]),['if-equal',_178306,'%Undefined%',[return,_178330],[eval,['if-equal',_178360,'Atom',[return,_178330],[eval,['if-equal',_178306,'Atom',[return,_178330],['if-unify',_178360,_178306,[return,_178330],[return,_178498]]]]]]],['_else'=_178498,'_type1'=_178360,'_then'=_178330,'_type2'=_178306],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(835,10),line_char(841,70))). -user:metta_file_buffer(10,304000920,indexed(metta_other,[eval,['if-equal',_179072,'%Undefined%',[return,_179118],[eval,['if-equal',_179172,'Atom',[return,_179118],[eval,['if-equal',_179072,'Atom',[return,_179118],['if-unify',_179172,_179072,[return,_179118],[return,_179430]]]]]]]]),[eval,['if-equal',_179494,'%Undefined%',[return,_179518],[eval,['if-equal',_179548,'Atom',[return,_179518],[eval,['if-equal',_179494,'Atom',[return,_179518],['if-unify',_179548,_179494,[return,_179518],[return,_179686]]]]]]]],['_else'=_179686,'_type1'=_179548,'_then'=_179518,'_type2'=_179494],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(835,4),line_char(841,71))). -user:metta_file_buffer(9,304000920,indexed(metta_other,['if-equal',_180262,'%Undefined%',[return,_180308],[eval,['if-equal',_180362,'%Undefined%',[return,_180308],[eval,['if-equal',_180262,'Atom',[return,_180308],[eval,['if-equal',_180362,'Atom',[return,_180308],['if-unify',_180262,_180362,[return,_180308],[return,_180712]]]]]]]]]),['if-equal',_180764,'%Undefined%',[return,_180788],[eval,['if-equal',_180818,'%Undefined%',[return,_180788],[eval,['if-equal',_180764,'Atom',[return,_180788],[eval,['if-equal',_180818,'Atom',[return,_180788],['if-unify',_180764,_180818,[return,_180788],[return,_181010]]]]]]]]],['_else'=_181010,'_type2'=_180818,'_then'=_180788,'_type1'=_180764],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(833,18),line_char(841,72))). -user:metta_file_buffer(8,304000920,indexed(metta_other,[eval,['if-equal',_181584,'%Undefined%',[return,_181630],[eval,['if-equal',_181684,'%Undefined%',[return,_181630],[eval,['if-equal',_181584,'Atom',[return,_181630],[eval,['if-equal',_181684,'Atom',[return,_181630],['if-unify',_181584,_181684,[return,_181630],[return,_182034]]]]]]]]]]),[eval,['if-equal',_182098,'%Undefined%',[return,_182122],[eval,['if-equal',_182152,'%Undefined%',[return,_182122],[eval,['if-equal',_182098,'Atom',[return,_182122],[eval,['if-equal',_182152,'Atom',[return,_182122],['if-unify',_182098,_182152,[return,_182122],[return,_182344]]]]]]]]]],['_else'=_182344,'_type2'=_182152,'_then'=_182122,'_type1'=_182098],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(833,12),line_char(841,73))). -user:metta_file_buffer(7,304000920,indexed(metta_other,[function,[eval,['if-equal',_182934,'%Undefined%',[return,_182980],[eval,['if-equal',_183034,'%Undefined%',[return,_182980],[eval,['if-equal',_182934,'Atom',[return,_182980],[eval,['if-equal',_183034,'Atom',[return,_182980],['if-unify',_182934,_183034,[return,_182980],[return,_183384]]]]]]]]]]]),[function,[eval,['if-equal',_183460,'%Undefined%',[return,_183484],[eval,['if-equal',_183514,'%Undefined%',[return,_183484],[eval,['if-equal',_183460,'Atom',[return,_183484],[eval,['if-equal',_183514,'Atom',[return,_183484],['if-unify',_183460,_183514,[return,_183484],[return,_183706]]]]]]]]]]],['_else'=_183706,'_type2'=_183514,'_then'=_183484,'_type1'=_183460],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(833,2),line_char(841,74))). -user:metta_file_buffer(6,304000920,indexed(metta_defun,['match-types',_184286,_184308,_184330,_184352]),[=,['match-types',_184920,_184926,_184932,_184938],[function,[eval,['if-equal',_184920,'%Undefined%',[return,_184932],[eval,['if-equal',_184926,'%Undefined%',[return,_184932],[eval,['if-equal',_184920,'Atom',[return,_184932],[eval,['if-equal',_184926,'Atom',[return,_184932],['if-unify',_184920,_184926,[return,_184932],[return,_184938]]]]]]]]]]]],['_else'=_184938,'_then'=_184932,'_type2'=_184926,'_type1'=_184920],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(832,0),line_char(841,75))). -user:metta_file_buffer(6,305000920,indexed(metta_comment,"; Helper MinimalMeTTa"),'$COMMENT'("; Helper MinimalMeTTa",843,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(843,0),line_char(843,21))). -user:metta_file_buffer(7,305000921,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(844,1),line_char(844,3))). -user:metta_file_buffer(7,305000921,constant,'first-from-pair',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(844,4),line_char(844,19))). -user:metta_file_buffer(7,305000921,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(844,20),line_char(844,38))). -user:metta_file_buffer(6,305000921,metta_other,[iz,'first-from-pair','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(844,0),line_char(844,39))). -user:metta_file_buffer(7,306000922,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(845,1),line_char(845,5))). -user:metta_file_buffer(7,306000922,constant,'first-from-pair',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(845,6),line_char(845,21))). -user:metta_file_buffer(8,306000923,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(846,3),line_char(846,8))). -user:metta_file_buffer(8,306000923,string,"Gets a pair as a first argument and returns first atom from pair",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(846,9),line_char(846,75))). -user:metta_file_buffer(7,306000923,metta_other,['@desc',"Gets a pair as a first argument and returns first atom from pair"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(846,2),line_char(846,76))). -user:metta_file_buffer(8,306000924,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(847,3),line_char(847,10))). -user:metta_file_buffer(10,306000926,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(848,5),line_char(848,11))). -user:metta_file_buffer(10,306000926,string,"Pair",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(848,12),line_char(848,18))). -user:metta_file_buffer(9,306000926,metta_other,['@param',"Pair"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(848,4),line_char(848,19))). -user:metta_file_buffer(8,306000926,array,[['@param',"Pair"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(847,11),line_char(848,20))). -user:metta_file_buffer(7,306000926,metta_other,['@params',[['@param',"Pair"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(847,2),line_char(848,21))). -user:metta_file_buffer(8,306000927,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(849,3),line_char(849,10))). -user:metta_file_buffer(8,306000927,string,"First atom from a pair",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(849,11),line_char(849,35))). -user:metta_file_buffer(7,306000927,metta_other,['@return',"First atom from a pair"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(849,2),line_char(849,36))). -user:metta_file_buffer(6,306000927,metta_other,['@doc','first-from-pair',['@desc',"Gets a pair as a first argument and returns first atom from pair"],['@params',[['@param',"Pair"]]],['@return',"First atom from a pair"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(845,0),line_char(849,37))). -user:metta_file_buffer(7,307000928,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(850,1),line_char(850,2))). -user:metta_file_buffer(8,307000929,constant,'first-from-pair',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(850,4),line_char(850,19))). -user:metta_file_buffer(8,307000929,variable,_151200,['_pair'=_151200],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(850,20),line_char(850,25))). -user:metta_file_buffer(7,307000929,indexed(metta_other,['first-from-pair',_152034]),['first-from-pair',_152086],['_pair'=_152086],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(850,3),line_char(850,26))). -user:metta_file_buffer(8,307000930,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(851,3),line_char(851,11))). -user:metta_file_buffer(9,307000931,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(852,5),line_char(852,13))). -user:metta_file_buffer(9,307000931,variable,_154670,['_pair'=_154670],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(852,14),line_char(852,19))). -user:metta_file_buffer(10,307000932,variable,_156108,['_first'=_156108],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(852,21),line_char(852,27))). -user:metta_file_buffer(10,307000932,variable,_157448,['_second'=_157448],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(852,28),line_char(852,35))). -user:metta_file_buffer(9,307000932,indexed(metta_other,[_158274,_158296]),[_158342,_158348],['_second'=_158348,'_first'=_158342],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(852,20),line_char(852,36))). -user:metta_file_buffer(10,307000933,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(853,7),line_char(853,13))). -user:metta_file_buffer(10,307000933,variable,_160182,['_first'=_160182],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(853,14),line_char(853,20))). -user:metta_file_buffer(9,307000933,indexed(metta_other,[return,_161016]),[return,_161068],['_first'=_161068],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(853,6),line_char(853,21))). -user:metta_file_buffer(10,307000934,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(854,7),line_char(854,13))). -user:metta_file_buffer(11,307000935,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(854,15),line_char(854,20))). -user:metta_file_buffer(12,307000936,constant,'first-from-pair',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(854,22),line_char(854,37))). -user:metta_file_buffer(12,307000936,variable,_164446,['_pair'=_164446],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(854,38),line_char(854,43))). -user:metta_file_buffer(11,307000936,indexed(metta_other,['first-from-pair',_165280]),['first-from-pair',_165332],['_pair'=_165332],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(854,21),line_char(854,44))). -user:metta_file_buffer(11,307000936,string,"incorrect pair format",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(854,45),line_char(854,68))). -user:metta_file_buffer(10,307000936,indexed(metta_other,['Error',['first-from-pair',_166646],"incorrect pair format"]),['Error',['first-from-pair',_166718],"incorrect pair format"],['_pair'=_166718],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(854,14),line_char(854,69))). -user:metta_file_buffer(9,307000936,indexed(metta_other,[return,['Error',['first-from-pair',_167272],"incorrect pair format"]]),[return,['Error',['first-from-pair',_167356],"incorrect pair format"]],['_pair'=_167356],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(854,6),line_char(854,70))). -user:metta_file_buffer(8,307000936,indexed(metta_other,['if-unify',_167896,[_167926,_167948],[return,_167926],[return,['Error',['first-from-pair',_167896],"incorrect pair format"]]]),['if-unify',_168108,[_168120,_168126],[return,_168120],[return,['Error',['first-from-pair',_168108],"incorrect pair format"]]],['_second'=_168126,'_first'=_168120,'_pair'=_168108],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(852,4),line_char(854,71))). -user:metta_file_buffer(7,307000936,indexed(metta_other,[function,['if-unify',_168748,[_168778,_168800],[return,_168778],[return,['Error',['first-from-pair',_168748],"incorrect pair format"]]]]),[function,['if-unify',_168972,[_168984,_168990],[return,_168984],[return,['Error',['first-from-pair',_168972],"incorrect pair format"]]]],['_second'=_168990,'_first'=_168984,'_pair'=_168972],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(851,2),line_char(854,72))). -user:metta_file_buffer(6,307000936,indexed(metta_defun,['first-from-pair',_169618]),[=,['first-from-pair',_169892],[function,['if-unify',_169892,[_169934,_169940],[return,_169934],[return,['Error',['first-from-pair',_169892],"incorrect pair format"]]]]],['_second'=_169940,'_first'=_169934,'_pair'=_169892],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(850,0),line_char(854,73))). -user:metta_file_buffer(7,308000937,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(856,1),line_char(856,3))). -user:metta_file_buffer(7,308000937,constant,'match-type-or',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(856,4),line_char(856,17))). -user:metta_file_buffer(7,308000937,constant,'HelperMM',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(856,18),line_char(856,26))). -user:metta_file_buffer(6,308000937,metta_other,[iz,'match-type-or','HelperMM'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(856,0),line_char(856,27))). -user:metta_file_buffer(7,309000938,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(857,1),line_char(857,5))). -user:metta_file_buffer(7,309000938,constant,'match-type-or',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(857,6),line_char(857,19))). -user:metta_file_buffer(8,309000939,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(858,3),line_char(858,8))). -user:metta_file_buffer(8,309000939,string,"Checks if two types (second and third arguments) can be unified and returns result of OR operation between first argument and type checking result",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(858,9),line_char(858,157))). -user:metta_file_buffer(7,309000939,metta_other,['@desc',"Checks if two types (second and third arguments) can be unified and returns result of OR operation between first argument and type checking result"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(858,2),line_char(858,158))). -user:metta_file_buffer(8,309000940,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(859,3),line_char(859,10))). -user:metta_file_buffer(10,309000942,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(860,5),line_char(860,11))). -user:metta_file_buffer(10,309000942,string,"Boolean value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(860,12),line_char(860,27))). -user:metta_file_buffer(9,309000942,metta_other,['@param',"Boolean value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(860,4),line_char(860,28))). -user:metta_file_buffer(10,309000943,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(861,5),line_char(861,11))). -user:metta_file_buffer(10,309000943,string,"First type",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(861,12),line_char(861,24))). -user:metta_file_buffer(9,309000943,metta_other,['@param',"First type"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(861,4),line_char(861,25))). -user:metta_file_buffer(10,309000944,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(862,5),line_char(862,11))). -user:metta_file_buffer(10,309000944,string,"Second type",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(862,12),line_char(862,25))). -user:metta_file_buffer(9,309000944,metta_other,['@param',"Second type"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(862,4),line_char(862,26))). -user:metta_file_buffer(8,309000944,array,[['@param',"Boolean value"],['@param',"First type"],['@param',"Second type"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(859,11),line_char(862,27))). -user:metta_file_buffer(7,309000944,metta_other,['@params',[['@param',"Boolean value"],['@param',"First type"],['@param',"Second type"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(859,2),line_char(862,28))). -user:metta_file_buffer(8,309000945,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(863,3),line_char(863,10))). -user:metta_file_buffer(8,309000945,string,"True or False",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(863,11),line_char(863,26))). -user:metta_file_buffer(7,309000945,metta_other,['@return',"True or False"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(863,2),line_char(863,27))). -user:metta_file_buffer(6,309000945,metta_other,['@doc','match-type-or',['@desc',"Checks if two types (second and third arguments) can be unified and returns result of OR operation between first argument and type checking result"],['@params',[['@param',"Boolean value"],['@param',"First type"],['@param',"Second type"]]],['@return',"True or False"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(857,0),line_char(863,28))). -user:metta_file_buffer(7,310000946,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(864,1),line_char(864,2))). -user:metta_file_buffer(8,310000947,constant,'match-type-or',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(864,4),line_char(864,17))). -user:metta_file_buffer(8,310000947,variable,_151220,['_folded'=_151220],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(864,18),line_char(864,25))). -user:metta_file_buffer(8,310000947,variable,_152504,['_next'=_152504],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(864,26),line_char(864,31))). -user:metta_file_buffer(8,310000947,variable,_153796,['_type'=_153796],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(864,32),line_char(864,37))). -user:metta_file_buffer(7,310000947,indexed(metta_other,['match-type-or',_154642,_154664,_154686]),['match-type-or',_154738,_154744,_154750],['_type'=_154750,'_next'=_154744,'_folded'=_154738],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(864,3),line_char(864,38))). -user:metta_file_buffer(8,310000948,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(865,3),line_char(865,11))). -user:metta_file_buffer(9,310000949,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(866,5),line_char(866,10))). -user:metta_file_buffer(10,310000950,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(866,12),line_char(866,16))). -user:metta_file_buffer(11,310000951,constant,'match-types',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(866,18),line_char(866,29))). -user:metta_file_buffer(11,310000951,variable,_158986,['_next'=_158986],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(866,30),line_char(866,35))). -user:metta_file_buffer(11,310000951,variable,_160270,['_type'=_160270],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(866,36),line_char(866,41))). -user:metta_file_buffer(11,310000951,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(866,42),line_char(866,46))). -user:metta_file_buffer(11,310000951,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(866,47),line_char(866,52))). -user:metta_file_buffer(10,310000951,indexed(metta_other,['match-types',_162316,_162338,'True','False']),['match-types',_162406,_162412,'True','False'],['_type'=_162412,'_next'=_162406],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(866,17),line_char(866,53))). -user:metta_file_buffer(9,310000951,indexed(metta_other,[eval,['match-types',_162962,_162984,'True','False']]),[eval,['match-types',_163064,_163070,'True','False']],['_type'=_163070,'_next'=_163064],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(866,11),line_char(866,54))). -user:metta_file_buffer(9,310000951,variable,_164118,['_matched'=_164118],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(866,55),line_char(866,63))). -user:metta_file_buffer(10,310000952,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(867,7),line_char(867,12))). -user:metta_file_buffer(11,310000953,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(867,14),line_char(867,18))). -user:metta_file_buffer(12,310000954,constant,or,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(867,20),line_char(867,22))). -user:metta_file_buffer(12,310000954,variable,_167834,['_folded'=_167834],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(867,23),line_char(867,30))). -user:metta_file_buffer(12,310000954,variable,_169190,['_matched'=_169190],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(867,31),line_char(867,39))). -user:metta_file_buffer(11,310000954,indexed(metta_other,[or,_170030,_170052]),[or,_170104,_170110],['_matched'=_170110,'_folded'=_170104],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(867,19),line_char(867,40))). -user:metta_file_buffer(10,310000954,indexed(metta_other,[eval,[or,_170660,_170682]]),[eval,[or,_170746,_170752]],['_matched'=_170752,'_folded'=_170746],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(867,13),line_char(867,41))). -user:metta_file_buffer(10,310000954,variable,_171704,['_or'=_171704],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(867,42),line_char(867,45))). -user:metta_file_buffer(11,310000955,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(867,47),line_char(867,53))). -user:metta_file_buffer(11,310000955,variable,_173778,['_or'=_173778],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(867,54),line_char(867,57))). -user:metta_file_buffer(10,310000955,indexed(metta_other,[return,_174612]),[return,_174664],['_or'=_174664],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(867,46),line_char(867,58))). -user:metta_file_buffer(9,310000955,indexed(metta_other,[chain,[eval,[or,_175230,_175252]],_175274,[return,_175274]]),[chain,[eval,[or,_175384,_175390]],_175396,[return,_175396]],['_or'=_175396,'_matched'=_175390,'_folded'=_175384],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(867,6),line_char(867,59))). -user:metta_file_buffer(8,310000955,indexed(metta_other,[chain,[eval,['match-types',_176006,_176028,'True','False']],_176066,[chain,[eval,[or,_176136,_176066]],_176176,[return,_176176]]]),[chain,[eval,['match-types',_176286,_176292,'True','False']],_176298,[chain,[eval,[or,_176340,_176298]],_176352,[return,_176352]]],['_or'=_176352,'_folded'=_176340,'_matched'=_176298,'_type'=_176292,'_next'=_176286],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(866,4),line_char(867,61))). -user:metta_file_buffer(7,310000955,indexed(metta_other,[function,[chain,[eval,['match-types',_176988,_177010,'True','False']],_177048,[chain,[eval,[or,_177118,_177048]],_177158,[return,_177158]]]]),[function,[chain,[eval,['match-types',_177280,_177286,'True','False']],_177292,[chain,[eval,[or,_177334,_177292]],_177346,[return,_177346]]]],['_or'=_177346,'_folded'=_177334,'_matched'=_177292,'_type'=_177286,'_next'=_177280],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(865,2),line_char(867,62))). -user:metta_file_buffer(6,310000955,indexed(metta_defun,['match-type-or',_177956,_177978,_178000]),[=,['match-type-or',_178342,_178348,_178354],[function,[chain,[eval,['match-types',_178348,_178354,'True','False']],_178420,[chain,[eval,[or,_178342,_178420]],_178474,[return,_178474]]]]],['_or'=_178474,'_matched'=_178420,'_type'=_178354,'_next'=_178348,'_folded'=_178342],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(864,0),line_char(867,63))). -user:metta_file_buffer(7,311000956,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(869,1),line_char(869,3))). -user:metta_file_buffer(7,311000956,constant,'filter-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(869,4),line_char(869,15))). -user:metta_file_buffer(7,311000956,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(869,16),line_char(869,21))). -user:metta_file_buffer(6,311000956,metta_other,[iz,'filter-atom','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(869,0),line_char(869,22))). -user:metta_file_buffer(7,312000957,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(870,1),line_char(870,5))). -user:metta_file_buffer(7,312000957,constant,'filter-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(870,6),line_char(870,17))). -user:metta_file_buffer(8,312000958,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(871,3),line_char(871,8))). -user:metta_file_buffer(8,312000958,string,"Function takes list of atoms (first argument), variable (second argument) and filter predicate (third argument) and returns list with items which passed filter. E.g. (filter-atom (1 2 3 4) $v (eval (> $v 2))) will give (3 4)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(871,9),line_char(871,235))). -user:metta_file_buffer(7,312000958,metta_other,['@desc',"Function takes list of atoms (first argument), variable (second argument) and filter predicate (third argument) and returns list with items which passed filter. E.g. (filter-atom (1 2 3 4) $v (eval (> $v 2))) will give (3 4)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(871,2),line_char(871,236))). -user:metta_file_buffer(8,312000959,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(872,3),line_char(872,10))). -user:metta_file_buffer(10,312000961,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(873,5),line_char(873,11))). -user:metta_file_buffer(10,312000961,string,"List of atoms",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(873,12),line_char(873,27))). -user:metta_file_buffer(9,312000961,metta_other,['@param',"List of atoms"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(873,4),line_char(873,28))). -user:metta_file_buffer(10,312000962,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(874,5),line_char(874,11))). -user:metta_file_buffer(10,312000962,string,"Variable",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(874,12),line_char(874,22))). -user:metta_file_buffer(9,312000962,metta_other,['@param',"Variable"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(874,4),line_char(874,23))). -user:metta_file_buffer(10,312000963,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(875,5),line_char(875,11))). -user:metta_file_buffer(10,312000963,string,"Filter predicate",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(875,12),line_char(875,30))). -user:metta_file_buffer(9,312000963,metta_other,['@param',"Filter predicate"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(875,4),line_char(875,31))). -user:metta_file_buffer(8,312000963,array,[['@param',"List of atoms"],['@param',"Variable"],['@param',"Filter predicate"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(872,11),line_char(875,32))). -user:metta_file_buffer(7,312000963,metta_other,['@params',[['@param',"List of atoms"],['@param',"Variable"],['@param',"Filter predicate"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(872,2),line_char(875,33))). -user:metta_file_buffer(8,312000964,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(876,3),line_char(876,10))). -user:metta_file_buffer(8,312000964,string,"Filtered list",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(876,11),line_char(876,26))). -user:metta_file_buffer(7,312000964,metta_other,['@return',"Filtered list"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(876,2),line_char(876,27))). -user:metta_file_buffer(6,312000964,metta_other,['@doc','filter-atom',['@desc',"Function takes list of atoms (first argument), variable (second argument) and filter predicate (third argument) and returns list with items which passed filter. E.g. (filter-atom (1 2 3 4) $v (eval (> $v 2))) will give (3 4)"],['@params',[['@param',"List of atoms"],['@param',"Variable"],['@param',"Filter predicate"]]],['@return',"Filtered list"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(870,0),line_char(876,28))). -user:metta_file_buffer(7,313000965,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(877,1),line_char(877,2))). -user:metta_file_buffer(7,313000965,constant,'filter-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(877,3),line_char(877,14))). -user:metta_file_buffer(8,313000966,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(877,16),line_char(877,18))). -user:metta_file_buffer(8,313000966,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(877,19),line_char(877,29))). -user:metta_file_buffer(8,313000966,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(877,30),line_char(877,38))). -user:metta_file_buffer(8,313000966,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(877,39),line_char(877,43))). -user:metta_file_buffer(8,313000966,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(877,44),line_char(877,54))). -user:metta_file_buffer(7,313000966,metta_other,[->,'Expression','Variable','Atom','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(877,15),line_char(877,55))). -user:metta_file_buffer(6,313000966,metta_typedecl,[:,'filter-atom',[->,'Expression','Variable','Atom','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(877,0),line_char(877,56))). -user:metta_file_buffer(7,314000967,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(878,1),line_char(878,2))). -user:metta_file_buffer(8,314000968,constant,'filter-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(878,4),line_char(878,15))). -user:metta_file_buffer(8,314000968,variable,_151152,['_list'=_151152],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(878,16),line_char(878,21))). -user:metta_file_buffer(8,314000968,variable,_152420,['_var'=_152420],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(878,22),line_char(878,26))). -user:metta_file_buffer(8,314000968,variable,_153760,['_filter'=_153760],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(878,27),line_char(878,34))). -user:metta_file_buffer(7,314000968,indexed(metta_other,['filter-atom',_154606,_154628,_154650]),['filter-atom',_154702,_154708,_154714],['_filter'=_154714,'_var'=_154708,'_list'=_154702],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(878,3),line_char(878,35))). -user:metta_file_buffer(8,314000969,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(879,3),line_char(879,11))). -user:metta_file_buffer(9,314000970,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(879,13),line_char(879,17))). -user:metta_file_buffer(10,314000971,constant,'if-decons-expr',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(879,19),line_char(879,33))). -user:metta_file_buffer(10,314000971,variable,_158168,['_list'=_158168],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(879,34),line_char(879,39))). -user:metta_file_buffer(10,314000971,variable,_159452,['_head'=_159452],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(879,40),line_char(879,45))). -user:metta_file_buffer(10,314000971,variable,_160736,['_tail'=_160736],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(879,46),line_char(879,51))). -user:metta_file_buffer(11,314000972,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(880,5),line_char(880,10))). -user:metta_file_buffer(12,314000973,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(880,12),line_char(880,16))). -user:metta_file_buffer(13,314000974,constant,'filter-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(880,18),line_char(880,29))). -user:metta_file_buffer(13,314000974,variable,_164422,['_tail'=_164422],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(880,30),line_char(880,35))). -user:metta_file_buffer(13,314000974,variable,_165690,['_var'=_165690],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(880,36),line_char(880,40))). -user:metta_file_buffer(13,314000974,variable,_167030,['_filter'=_167030],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(880,41),line_char(880,48))). -user:metta_file_buffer(12,314000974,indexed(metta_other,['filter-atom',_167876,_167898,_167920]),['filter-atom',_167972,_167978,_167984],['_filter'=_167984,'_var'=_167978,'_tail'=_167972],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(880,17),line_char(880,49))). -user:metta_file_buffer(11,314000974,indexed(metta_other,[eval,['filter-atom',_168546,_168568,_168590]]),[eval,['filter-atom',_168654,_168660,_168666]],['_filter'=_168666,'_var'=_168660,'_tail'=_168654],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(880,11),line_char(880,50))). -user:metta_file_buffer(11,314000974,variable,_169828,['_tail_filtered'=_169828],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(880,51),line_char(880,65))). -user:metta_file_buffer(12,314000975,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(881,7),line_char(881,12))). -user:metta_file_buffer(13,314000976,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(881,14),line_char(881,18))). -user:metta_file_buffer(14,314000977,constant,'atom-subst',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(881,20),line_char(881,30))). -user:metta_file_buffer(14,314000977,variable,_173508,['_head'=_173508],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(881,31),line_char(881,36))). -user:metta_file_buffer(14,314000977,variable,_174776,['_var'=_174776],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(881,37),line_char(881,41))). -user:metta_file_buffer(14,314000977,variable,_176116,['_filter'=_176116],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(881,42),line_char(881,49))). -user:metta_file_buffer(13,314000977,indexed(metta_other,['atom-subst',_176962,_176984,_177006]),['atom-subst',_177058,_177064,_177070],['_filter'=_177070,'_var'=_177064,'_head'=_177058],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(881,19),line_char(881,50))). -user:metta_file_buffer(12,314000977,indexed(metta_other,[eval,['atom-subst',_177632,_177654,_177676]]),[eval,['atom-subst',_177740,_177746,_177752]],['_filter'=_177752,'_var'=_177746,'_head'=_177740],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(881,13),line_char(881,51))). -user:metta_file_buffer(12,314000977,variable,_178882,['_filter_expr'=_178882],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(881,52),line_char(881,64))). -user:metta_file_buffer(13,314000978,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(882,9),line_char(882,14))). -user:metta_file_buffer(13,314000978,variable,_181120,['_filter_expr'=_181120],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(882,15),line_char(882,27))). -user:metta_file_buffer(13,314000978,variable,_182538,['_is_filtered'=_182538],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(882,28),line_char(882,40))). -user:metta_file_buffer(14,314000979,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(883,11),line_char(883,15))). -user:metta_file_buffer(15,314000980,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(883,17),line_char(883,19))). -user:metta_file_buffer(15,314000980,variable,_185544,['_is_filtered'=_185544],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(883,20),line_char(883,32))). -user:metta_file_buffer(16,314000981,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(884,13),line_char(884,18))). -user:metta_file_buffer(17,314000982,constant,'cons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(884,20),line_char(884,29))). -user:metta_file_buffer(17,314000982,variable,_188432,['_head'=_188432],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(884,30),line_char(884,35))). -user:metta_file_buffer(17,314000982,variable,_189890,['_tail_filtered'=_189890],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(884,36),line_char(884,50))). -user:metta_file_buffer(16,314000982,indexed(metta_other,['cons-atom',_190730,_190752]),['cons-atom',_190804,_190810],['_tail_filtered'=_190810,'_head'=_190804],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(884,19),line_char(884,51))). -user:metta_file_buffer(16,314000982,variable,_191778,['_res'=_191778],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(884,52),line_char(884,56))). -user:metta_file_buffer(17,314000983,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(884,58),line_char(884,64))). -user:metta_file_buffer(17,314000983,variable,_193868,['_res'=_193868],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(884,65),line_char(884,69))). -user:metta_file_buffer(16,314000983,indexed(metta_other,[return,_194702]),[return,_194754],['_res'=_194754],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(884,57),line_char(884,70))). -user:metta_file_buffer(15,314000983,indexed(metta_other,[chain,['cons-atom',_195304,_195326],_195348,[return,_195348]]),[chain,['cons-atom',_195446,_195452],_195458,[return,_195458]],['_res'=_195458,'_tail_filtered'=_195452,'_head'=_195446],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(884,12),line_char(884,71))). -user:metta_file_buffer(16,314000984,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(885,13),line_char(885,19))). -user:metta_file_buffer(16,314000984,variable,_197484,['_tail_filtered'=_197484],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(885,20),line_char(885,34))). -user:metta_file_buffer(15,314000984,indexed(metta_other,[return,_198318]),[return,_198370],['_tail_filtered'=_198370],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(885,12),line_char(885,35))). -user:metta_file_buffer(14,314000984,indexed(metta_other,[if,_198906,[chain,['cons-atom',_198960,_198982],_199004,[return,_199004]],[return,_198982]]),[if,_199124,[chain,['cons-atom',_199154,_199160],_199166,[return,_199166]],[return,_199160]],['_res'=_199166,'_tail_filtered'=_199160,'_head'=_199154,'_is_filtered'=_199124],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(883,16),line_char(885,37))). -user:metta_file_buffer(13,314000984,indexed(metta_other,[eval,[if,_199776,[chain,['cons-atom',_199830,_199852],_199874,[return,_199874]],[return,_199852]]]),[eval,[if,_200006,[chain,['cons-atom',_200036,_200042],_200048,[return,_200048]],[return,_200042]]],['_res'=_200048,'_tail_filtered'=_200042,'_head'=_200036,'_is_filtered'=_200006],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(883,10),line_char(885,38))). -user:metta_file_buffer(12,314000984,indexed(metta_other,[chain,_200654,_200676,[eval,[if,_200676,[chain,['cons-atom',_200780,_200802],_200824,[return,_200824]],[return,_200802]]]]),[chain,_200944,_200950,[eval,[if,_200950,[chain,['cons-atom',_201010,_201016],_201022,[return,_201022]],[return,_201016]]]],['_res'=_201022,'_tail_filtered'=_201016,'_head'=_201010,'_is_filtered'=_200950,'_filter_expr'=_200944],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(882,8),line_char(885,39))). -user:metta_file_buffer(11,314000984,indexed(metta_other,[chain,[eval,['atom-subst',_201672,_201694,_201716]],_201738,[chain,_201738,_201794,[eval,[if,_201794,[chain,['cons-atom',_201672,_201916],_201938,[return,_201938]],[return,_201916]]]]]),[chain,[eval,['atom-subst',_202082,_202088,_202094]],_202100,[chain,_202100,_202124,[eval,[if,_202124,[chain,['cons-atom',_202082,_202190],_202196,[return,_202196]],[return,_202190]]]]],['_res'=_202196,'_tail_filtered'=_202190,'_is_filtered'=_202124,'_filter_expr'=_202100,'_filter'=_202094,'_var'=_202088,'_head'=_202082],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(881,6),line_char(885,40))). -user:metta_file_buffer(10,314000984,indexed(metta_other,[chain,[eval,['filter-atom',_202870,_202892,_202914]],_202936,[chain,[eval,['atom-subst',_203006,_202892,_202914]],_203064,[chain,_203064,_203120,[eval,[if,_203120,[chain,['cons-atom',_203006,_202936],_203260,[return,_203260]],[return,_202936]]]]]]),[chain,[eval,['filter-atom',_203404,_203410,_203416]],_203422,[chain,[eval,['atom-subst',_203464,_203410,_203416]],_203482,[chain,_203482,_203506,[eval,[if,_203506,[chain,['cons-atom',_203464,_203422],_203578,[return,_203578]],[return,_203422]]]]]],['_res'=_203578,'_is_filtered'=_203506,'_filter_expr'=_203482,'_head'=_203464,'_tail_filtered'=_203422,'_filter'=_203416,'_var'=_203410,'_tail'=_203404],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(880,4),line_char(885,41))). -user:metta_file_buffer(11,314000985,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(886,5),line_char(886,11))). -user:metta_file_buffer(11,314000986,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(886,12),line_char(886,14))). -user:metta_file_buffer(10,314000986,metta_other,[return,[]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(886,4),line_char(886,15))). -user:metta_file_buffer(9,314000986,indexed(metta_other,['if-decons-expr',_206252,_206274,_206296,[chain,[eval,['filter-atom',_206296,_206384,_206406]],_206428,[chain,[eval,['atom-subst',_206274,_206384,_206406]],_206552,[chain,_206552,_206608,[eval,[if,_206608,[chain,['cons-atom',_206274,_206428],_206748,[return,_206748]],[return,_206428]]]]]],[return,[]]]),['if-decons-expr',_206892,_206898,_206904,[chain,[eval,['filter-atom',_206904,_206952,_206958]],_206964,[chain,[eval,['atom-subst',_206898,_206952,_206958]],_207024,[chain,_207024,_207048,[eval,[if,_207048,[chain,['cons-atom',_206898,_206964],_207120,[return,_207120]],[return,_206964]]]]]],[return,[]]],['_res'=_207120,'_is_filtered'=_207048,'_filter_expr'=_207024,'_tail_filtered'=_206964,'_filter'=_206958,'_var'=_206952,'_tail'=_206904,'_head'=_206898,'_list'=_206892],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(879,18),line_char(886,17))). -user:metta_file_buffer(8,314000986,indexed(metta_other,[eval,['if-decons-expr',_207790,_207812,_207834,[chain,[eval,['filter-atom',_207834,_207922,_207944]],_207966,[chain,[eval,['atom-subst',_207812,_207922,_207944]],_208090,[chain,_208090,_208146,[eval,[if,_208146,[chain,['cons-atom',_207812,_207966],_208286,[return,_208286]],[return,_207966]]]]]],[return,[]]]]),[eval,['if-decons-expr',_208442,_208448,_208454,[chain,[eval,['filter-atom',_208454,_208502,_208508]],_208514,[chain,[eval,['atom-subst',_208448,_208502,_208508]],_208574,[chain,_208574,_208598,[eval,[if,_208598,[chain,['cons-atom',_208448,_208514],_208670,[return,_208670]],[return,_208514]]]]]],[return,[]]]],['_res'=_208670,'_is_filtered'=_208598,'_filter_expr'=_208574,'_tail_filtered'=_208514,'_filter'=_208508,'_var'=_208502,'_tail'=_208454,'_head'=_208448,'_list'=_208442],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(879,12),line_char(886,18))). -user:metta_file_buffer(7,314000986,indexed(metta_other,[function,[eval,['if-decons-expr',_209356,_209378,_209400,[chain,[eval,['filter-atom',_209400,_209488,_209510]],_209532,[chain,[eval,['atom-subst',_209378,_209488,_209510]],_209656,[chain,_209656,_209712,[eval,[if,_209712,[chain,['cons-atom',_209378,_209532],_209852,[return,_209852]],[return,_209532]]]]]],[return,[]]]]]),[function,[eval,['if-decons-expr',_210020,_210026,_210032,[chain,[eval,['filter-atom',_210032,_210080,_210086]],_210092,[chain,[eval,['atom-subst',_210026,_210080,_210086]],_210152,[chain,_210152,_210176,[eval,[if,_210176,[chain,['cons-atom',_210026,_210092],_210248,[return,_210248]],[return,_210092]]]]]],[return,[]]]]],['_res'=_210248,'_is_filtered'=_210176,'_filter_expr'=_210152,'_tail_filtered'=_210092,'_filter'=_210086,'_var'=_210080,'_tail'=_210032,'_head'=_210026,'_list'=_210020],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(879,2),line_char(886,19))). -user:metta_file_buffer(6,314000986,indexed(metta_defun,['filter-atom',_210924,_210946,_210968]),[=,['filter-atom',_211678,_211684,_211690],[function,[eval,['if-decons-expr',_211678,_211738,_211744,[chain,[eval,['filter-atom',_211744,_211684,_211690]],_211804,[chain,[eval,['atom-subst',_211738,_211684,_211690]],_211864,[chain,_211864,_211888,[eval,[if,_211888,[chain,['cons-atom',_211738,_211804],_211960,[return,_211960]],[return,_211804]]]]]],[return,[]]]]]],['_res'=_211960,'_is_filtered'=_211888,'_filter_expr'=_211864,'_tail_filtered'=_211804,'_tail'=_211744,'_head'=_211738,'_filter'=_211690,'_var'=_211684,'_list'=_211678],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(878,0),line_char(886,20))). -user:metta_file_buffer(7,315000987,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(888,1),line_char(888,3))). -user:metta_file_buffer(7,315000987,constant,'map-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(888,4),line_char(888,12))). -user:metta_file_buffer(7,315000987,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(888,13),line_char(888,18))). -user:metta_file_buffer(6,315000987,metta_other,[iz,'map-atom','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(888,0),line_char(888,19))). -user:metta_file_buffer(7,316000988,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(889,1),line_char(889,5))). -user:metta_file_buffer(7,316000988,constant,'map-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(889,6),line_char(889,14))). -user:metta_file_buffer(8,316000989,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(890,3),line_char(890,8))). -user:metta_file_buffer(8,316000989,string,"Function takes list of atoms (first argument), variable to be used inside (second variable) and an expression which will be evaluated for each atom in list (third argument). Expression should contain variable. So e.g. (map-atom (1 2 3 4) $v (eval (+ $v 1))) will give (2 3 4 5)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(890,9),line_char(890,288))). -user:metta_file_buffer(7,316000989,metta_other,['@desc',"Function takes list of atoms (first argument), variable to be used inside (second variable) and an expression which will be evaluated for each atom in list (third argument). Expression should contain variable. So e.g. (map-atom (1 2 3 4) $v (eval (+ $v 1))) will give (2 3 4 5)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(890,2),line_char(890,289))). -user:metta_file_buffer(8,316000990,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(891,3),line_char(891,10))). -user:metta_file_buffer(10,316000992,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(892,5),line_char(892,11))). -user:metta_file_buffer(10,316000992,string,"List of atoms",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(892,12),line_char(892,27))). -user:metta_file_buffer(9,316000992,metta_other,['@param',"List of atoms"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(892,4),line_char(892,28))). -user:metta_file_buffer(10,316000993,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(893,5),line_char(893,11))). -user:metta_file_buffer(10,316000993,string,"Variable name",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(893,12),line_char(893,27))). -user:metta_file_buffer(9,316000993,metta_other,['@param',"Variable name"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(893,4),line_char(893,28))). -user:metta_file_buffer(10,316000994,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(894,5),line_char(894,11))). -user:metta_file_buffer(10,316000994,string,"Template using variable",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(894,12),line_char(894,37))). -user:metta_file_buffer(9,316000994,metta_other,['@param',"Template using variable"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(894,4),line_char(894,38))). -user:metta_file_buffer(8,316000994,array,[['@param',"List of atoms"],['@param',"Variable name"],['@param',"Template using variable"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(891,11),line_char(894,39))). -user:metta_file_buffer(7,316000994,metta_other,['@params',[['@param',"List of atoms"],['@param',"Variable name"],['@param',"Template using variable"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(891,2),line_char(894,40))). -user:metta_file_buffer(8,316000995,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(895,3),line_char(895,10))). -user:metta_file_buffer(8,316000995,string,"Result of evaluating template for each atom in a list",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(895,11),line_char(895,66))). -user:metta_file_buffer(7,316000995,metta_other,['@return',"Result of evaluating template for each atom in a list"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(895,2),line_char(895,67))). -user:metta_file_buffer(6,316000995,metta_other,['@doc','map-atom',['@desc',"Function takes list of atoms (first argument), variable to be used inside (second variable) and an expression which will be evaluated for each atom in list (third argument). Expression should contain variable. So e.g. (map-atom (1 2 3 4) $v (eval (+ $v 1))) will give (2 3 4 5)"],['@params',[['@param',"List of atoms"],['@param',"Variable name"],['@param',"Template using variable"]]],['@return',"Result of evaluating template for each atom in a list"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(889,0),line_char(895,68))). -user:metta_file_buffer(7,317000996,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(896,1),line_char(896,2))). -user:metta_file_buffer(7,317000996,constant,'map-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(896,3),line_char(896,11))). -user:metta_file_buffer(8,317000997,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(896,13),line_char(896,15))). -user:metta_file_buffer(8,317000997,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(896,16),line_char(896,26))). -user:metta_file_buffer(8,317000997,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(896,27),line_char(896,35))). -user:metta_file_buffer(8,317000997,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(896,36),line_char(896,40))). -user:metta_file_buffer(8,317000997,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(896,41),line_char(896,51))). -user:metta_file_buffer(7,317000997,metta_other,[->,'Expression','Variable','Atom','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(896,12),line_char(896,52))). -user:metta_file_buffer(6,317000997,metta_typedecl,[:,'map-atom',[->,'Expression','Variable','Atom','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(896,0),line_char(896,53))). -user:metta_file_buffer(7,318000998,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(897,1),line_char(897,2))). -user:metta_file_buffer(8,318000999,constant,'map-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(897,4),line_char(897,12))). -user:metta_file_buffer(8,318000999,variable,_151122,['_list'=_151122],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(897,13),line_char(897,18))). -user:metta_file_buffer(8,318000999,variable,_152390,['_var'=_152390],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(897,19),line_char(897,23))). -user:metta_file_buffer(8,318000999,variable,_153666,['_map'=_153666],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(897,24),line_char(897,28))). -user:metta_file_buffer(7,318000999,indexed(metta_other,['map-atom',_154512,_154534,_154556]),['map-atom',_154608,_154614,_154620],['_map'=_154620,'_var'=_154614,'_list'=_154608],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(897,3),line_char(897,29))). -user:metta_file_buffer(8,318001000,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(898,3),line_char(898,11))). -user:metta_file_buffer(9,318001001,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(898,13),line_char(898,17))). -user:metta_file_buffer(10,318001002,constant,'if-decons-expr',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(898,19),line_char(898,33))). -user:metta_file_buffer(10,318001002,variable,_158074,['_list'=_158074],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(898,34),line_char(898,39))). -user:metta_file_buffer(10,318001002,variable,_159358,['_head'=_159358],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(898,40),line_char(898,45))). -user:metta_file_buffer(10,318001002,variable,_160642,['_tail'=_160642],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(898,46),line_char(898,51))). -user:metta_file_buffer(11,318001003,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(899,5),line_char(899,10))). -user:metta_file_buffer(12,318001004,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(899,12),line_char(899,16))). -user:metta_file_buffer(13,318001005,constant,'map-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(899,18),line_char(899,26))). -user:metta_file_buffer(13,318001005,variable,_164298,['_tail'=_164298],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(899,27),line_char(899,32))). -user:metta_file_buffer(13,318001005,variable,_165566,['_var'=_165566],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(899,33),line_char(899,37))). -user:metta_file_buffer(13,318001005,variable,_166842,['_map'=_166842],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(899,38),line_char(899,42))). -user:metta_file_buffer(12,318001005,indexed(metta_other,['map-atom',_167688,_167710,_167732]),['map-atom',_167784,_167790,_167796],['_map'=_167796,'_var'=_167790,'_tail'=_167784],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(899,17),line_char(899,43))). -user:metta_file_buffer(11,318001005,indexed(metta_other,[eval,['map-atom',_168358,_168380,_168402]]),[eval,['map-atom',_168466,_168472,_168478]],['_map'=_168478,'_var'=_168472,'_tail'=_168466],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(899,11),line_char(899,44))). -user:metta_file_buffer(11,318001005,variable,_169608,['_tail_mapped'=_169608],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(899,45),line_char(899,57))). -user:metta_file_buffer(12,318001006,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(900,7),line_char(900,12))). -user:metta_file_buffer(13,318001007,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(900,14),line_char(900,18))). -user:metta_file_buffer(14,318001008,constant,'atom-subst',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(900,20),line_char(900,30))). -user:metta_file_buffer(14,318001008,variable,_173288,['_head'=_173288],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(900,31),line_char(900,36))). -user:metta_file_buffer(14,318001008,variable,_174556,['_var'=_174556],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(900,37),line_char(900,41))). -user:metta_file_buffer(14,318001008,variable,_175832,['_map'=_175832],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(900,42),line_char(900,46))). -user:metta_file_buffer(13,318001008,indexed(metta_other,['atom-subst',_176678,_176700,_176722]),['atom-subst',_176774,_176780,_176786],['_map'=_176786,'_var'=_176780,'_head'=_176774],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(900,19),line_char(900,47))). -user:metta_file_buffer(12,318001008,indexed(metta_other,[eval,['atom-subst',_177348,_177370,_177392]]),[eval,['atom-subst',_177456,_177462,_177468]],['_map'=_177468,'_var'=_177462,'_head'=_177456],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(900,13),line_char(900,48))). -user:metta_file_buffer(12,318001008,variable,_178550,['_map_expr'=_178550],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(900,49),line_char(900,58))). -user:metta_file_buffer(13,318001009,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(901,9),line_char(901,14))). -user:metta_file_buffer(13,318001009,variable,_180740,['_map_expr'=_180740],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(901,15),line_char(901,24))). -user:metta_file_buffer(13,318001009,variable,_182158,['_head_mapped'=_182158],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(901,25),line_char(901,37))). -user:metta_file_buffer(14,318001010,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(902,11),line_char(902,16))). -user:metta_file_buffer(15,318001011,constant,'cons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(902,18),line_char(902,27))). -user:metta_file_buffer(15,318001011,variable,_185176,['_head_mapped'=_185176],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(902,28),line_char(902,40))). -user:metta_file_buffer(15,318001011,variable,_186602,['_tail_mapped'=_186602],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(902,41),line_char(902,53))). -user:metta_file_buffer(14,318001011,indexed(metta_other,['cons-atom',_187442,_187464]),['cons-atom',_187516,_187522],['_tail_mapped'=_187522,'_head_mapped'=_187516],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(902,17),line_char(902,54))). -user:metta_file_buffer(14,318001011,variable,_188490,['_res'=_188490],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(902,55),line_char(902,59))). -user:metta_file_buffer(15,318001012,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(902,61),line_char(902,67))). -user:metta_file_buffer(15,318001012,variable,_190580,['_res'=_190580],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(902,68),line_char(902,72))). -user:metta_file_buffer(14,318001012,indexed(metta_other,[return,_191414]),[return,_191466],['_res'=_191466],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(902,60),line_char(902,73))). -user:metta_file_buffer(13,318001012,indexed(metta_other,[chain,['cons-atom',_192016,_192038],_192060,[return,_192060]]),[chain,['cons-atom',_192158,_192164],_192170,[return,_192170]],['_res'=_192170,'_tail_mapped'=_192164,'_head_mapped'=_192158],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(902,10),line_char(902,74))). -user:metta_file_buffer(12,318001012,indexed(metta_other,[chain,_192748,_192770,[chain,['cons-atom',_192770,_192842],_192864,[return,_192864]]]),[chain,_192950,_192956,[chain,['cons-atom',_192956,_192992],_192998,[return,_192998]]],['_res'=_192998,'_tail_mapped'=_192992,'_head_mapped'=_192956,'_map_expr'=_192950],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(901,8),line_char(902,76))). -user:metta_file_buffer(11,318001012,indexed(metta_other,[chain,[eval,['atom-subst',_193618,_193640,_193662]],_193684,[chain,_193684,_193740,[chain,['cons-atom',_193740,_193812],_193834,[return,_193834]]]]),[chain,[eval,['atom-subst',_193944,_193950,_193956]],_193962,[chain,_193962,_193986,[chain,['cons-atom',_193986,_194022],_194028,[return,_194028]]]],['_res'=_194028,'_tail_mapped'=_194022,'_head_mapped'=_193986,'_map_expr'=_193962,'_map'=_193956,'_var'=_193950,'_head'=_193944],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(900,6),line_char(902,77))). -user:metta_file_buffer(10,318001012,indexed(metta_other,[chain,[eval,['map-atom',_194684,_194706,_194728]],_194750,[chain,[eval,['atom-subst',_194820,_194706,_194728]],_194878,[chain,_194878,_194934,[chain,['cons-atom',_194934,_194750],_195024,[return,_195024]]]]]),[chain,[eval,['map-atom',_195134,_195140,_195146]],_195152,[chain,[eval,['atom-subst',_195194,_195140,_195146]],_195212,[chain,_195212,_195236,[chain,['cons-atom',_195236,_195152],_195278,[return,_195278]]]]],['_res'=_195278,'_head_mapped'=_195236,'_map_expr'=_195212,'_head'=_195194,'_tail_mapped'=_195152,'_map'=_195146,'_var'=_195140,'_tail'=_195134],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(899,4),line_char(902,78))). -user:metta_file_buffer(11,318001013,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(903,5),line_char(903,11))). -user:metta_file_buffer(11,318001014,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(903,12),line_char(903,14))). -user:metta_file_buffer(10,318001014,metta_other,[return,[]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(903,4),line_char(903,15))). -user:metta_file_buffer(9,318001014,indexed(metta_other,['if-decons-expr',_197934,_197956,_197978,[chain,[eval,['map-atom',_197978,_198066,_198088]],_198110,[chain,[eval,['atom-subst',_197956,_198066,_198088]],_198234,[chain,_198234,_198290,[chain,['cons-atom',_198290,_198110],_198380,[return,_198380]]]]],[return,[]]]),['if-decons-expr',_198490,_198496,_198502,[chain,[eval,['map-atom',_198502,_198550,_198556]],_198562,[chain,[eval,['atom-subst',_198496,_198550,_198556]],_198622,[chain,_198622,_198646,[chain,['cons-atom',_198646,_198562],_198688,[return,_198688]]]]],[return,[]]],['_res'=_198688,'_head_mapped'=_198646,'_map_expr'=_198622,'_tail_mapped'=_198562,'_map'=_198556,'_var'=_198550,'_tail'=_198502,'_head'=_198496,'_list'=_198490],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(898,18),line_char(903,17))). -user:metta_file_buffer(8,318001014,indexed(metta_other,[eval,['if-decons-expr',_199340,_199362,_199384,[chain,[eval,['map-atom',_199384,_199472,_199494]],_199516,[chain,[eval,['atom-subst',_199362,_199472,_199494]],_199640,[chain,_199640,_199696,[chain,['cons-atom',_199696,_199516],_199786,[return,_199786]]]]],[return,[]]]]),[eval,['if-decons-expr',_199908,_199914,_199920,[chain,[eval,['map-atom',_199920,_199968,_199974]],_199980,[chain,[eval,['atom-subst',_199914,_199968,_199974]],_200040,[chain,_200040,_200064,[chain,['cons-atom',_200064,_199980],_200106,[return,_200106]]]]],[return,[]]]],['_res'=_200106,'_head_mapped'=_200064,'_map_expr'=_200040,'_tail_mapped'=_199980,'_map'=_199974,'_var'=_199968,'_tail'=_199920,'_head'=_199914,'_list'=_199908],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(898,12),line_char(903,18))). -user:metta_file_buffer(7,318001014,indexed(metta_other,[function,[eval,['if-decons-expr',_200774,_200796,_200818,[chain,[eval,['map-atom',_200818,_200906,_200928]],_200950,[chain,[eval,['atom-subst',_200796,_200906,_200928]],_201074,[chain,_201074,_201130,[chain,['cons-atom',_201130,_200950],_201220,[return,_201220]]]]],[return,[]]]]]),[function,[eval,['if-decons-expr',_201354,_201360,_201366,[chain,[eval,['map-atom',_201366,_201414,_201420]],_201426,[chain,[eval,['atom-subst',_201360,_201414,_201420]],_201486,[chain,_201486,_201510,[chain,['cons-atom',_201510,_201426],_201552,[return,_201552]]]]],[return,[]]]]],['_res'=_201552,'_head_mapped'=_201510,'_map_expr'=_201486,'_tail_mapped'=_201426,'_map'=_201420,'_var'=_201414,'_tail'=_201366,'_head'=_201360,'_list'=_201354],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(898,2),line_char(903,19))). -user:metta_file_buffer(6,318001014,indexed(metta_defun,['map-atom',_202210,_202232,_202254]),[=,['map-atom',_202880,_202886,_202892],[function,[eval,['if-decons-expr',_202880,_202940,_202946,[chain,[eval,['map-atom',_202946,_202886,_202892]],_203006,[chain,[eval,['atom-subst',_202940,_202886,_202892]],_203066,[chain,_203066,_203090,[chain,['cons-atom',_203090,_203006],_203132,[return,_203132]]]]],[return,[]]]]]],['_res'=_203132,'_head_mapped'=_203090,'_map_expr'=_203066,'_tail_mapped'=_203006,'_tail'=_202946,'_head'=_202940,'_map'=_202892,'_var'=_202886,'_list'=_202880],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(897,0),line_char(903,20))). -user:metta_file_buffer(7,319001015,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(905,1),line_char(905,3))). -user:metta_file_buffer(7,319001015,constant,'foldl-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(905,4),line_char(905,14))). -user:metta_file_buffer(7,319001015,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(905,15),line_char(905,20))). -user:metta_file_buffer(6,319001015,metta_other,[iz,'foldl-atom','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(905,0),line_char(905,21))). -user:metta_file_buffer(7,320001016,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(906,1),line_char(906,5))). -user:metta_file_buffer(7,320001016,constant,'foldl-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(906,6),line_char(906,16))). -user:metta_file_buffer(8,320001017,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(907,3),line_char(907,8))). -user:metta_file_buffer(8,320001017,string,"Function takes list of values (first argument), initial value (second argument) and operation (fifth argument) and applies it consequently to the list of values, using init value as a start. It also takes two variables (third and fourth argument) to use them inside",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(907,9),line_char(907,276))). -user:metta_file_buffer(7,320001017,metta_other,['@desc',"Function takes list of values (first argument), initial value (second argument) and operation (fifth argument) and applies it consequently to the list of values, using init value as a start. It also takes two variables (third and fourth argument) to use them inside"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(907,2),line_char(907,277))). -user:metta_file_buffer(8,320001018,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(908,3),line_char(908,10))). -user:metta_file_buffer(10,320001020,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(909,5),line_char(909,11))). -user:metta_file_buffer(10,320001020,string,"List of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(909,12),line_char(909,28))). -user:metta_file_buffer(9,320001020,metta_other,['@param',"List of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(909,4),line_char(909,29))). -user:metta_file_buffer(10,320001021,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(910,5),line_char(910,11))). -user:metta_file_buffer(10,320001021,string,"Init value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(910,12),line_char(910,24))). -user:metta_file_buffer(9,320001021,metta_other,['@param',"Init value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(910,4),line_char(910,25))). -user:metta_file_buffer(10,320001022,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(911,5),line_char(911,11))). -user:metta_file_buffer(10,320001022,string,"Variable",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(911,12),line_char(911,22))). -user:metta_file_buffer(9,320001022,metta_other,['@param',"Variable"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(911,4),line_char(911,23))). -user:metta_file_buffer(10,320001023,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(912,5),line_char(912,11))). -user:metta_file_buffer(10,320001023,string,"Variable",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(912,12),line_char(912,22))). -user:metta_file_buffer(9,320001023,metta_other,['@param',"Variable"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(912,4),line_char(912,23))). -user:metta_file_buffer(10,320001024,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(913,5),line_char(913,11))). -user:metta_file_buffer(10,320001024,string,"Operation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(913,12),line_char(913,23))). -user:metta_file_buffer(9,320001024,metta_other,['@param',"Operation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(913,4),line_char(913,24))). -user:metta_file_buffer(8,320001024,array,[['@param',"List of values"],['@param',"Init value"],['@param',"Variable"],['@param',"Variable"],['@param',"Operation"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(908,11),line_char(913,25))). -user:metta_file_buffer(7,320001024,metta_other,['@params',[['@param',"List of values"],['@param',"Init value"],['@param',"Variable"],['@param',"Variable"],['@param',"Operation"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(908,2),line_char(913,26))). -user:metta_file_buffer(8,320001025,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(914,3),line_char(914,10))). -user:metta_file_buffer(8,320001025,string,"Result of applying operation to the list of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(914,11),line_char(914,63))). -user:metta_file_buffer(7,320001025,metta_other,['@return',"Result of applying operation to the list of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(914,2),line_char(914,64))). -user:metta_file_buffer(6,320001025,metta_other,['@doc','foldl-atom',['@desc',"Function takes list of values (first argument), initial value (second argument) and operation (fifth argument) and applies it consequently to the list of values, using init value as a start. It also takes two variables (third and fourth argument) to use them inside"],['@params',[['@param',"List of values"],['@param',"Init value"],['@param',"Variable"],['@param',"Variable"],['@param',"Operation"]]],['@return',"Result of applying operation to the list of values"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(906,0),line_char(914,65))). -user:metta_file_buffer(7,321001026,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(915,1),line_char(915,2))). -user:metta_file_buffer(7,321001026,constant,'foldl-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(915,3),line_char(915,13))). -user:metta_file_buffer(8,321001027,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(915,15),line_char(915,17))). -user:metta_file_buffer(8,321001027,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(915,18),line_char(915,28))). -user:metta_file_buffer(8,321001027,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(915,29),line_char(915,33))). -user:metta_file_buffer(8,321001027,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(915,34),line_char(915,42))). -user:metta_file_buffer(8,321001027,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(915,43),line_char(915,51))). -user:metta_file_buffer(8,321001027,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(915,52),line_char(915,56))). -user:metta_file_buffer(8,321001027,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(915,57),line_char(915,61))). -user:metta_file_buffer(7,321001027,metta_other,[->,'Expression','Atom','Variable','Variable','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(915,14),line_char(915,62))). -user:metta_file_buffer(6,321001027,metta_typedecl,[:,'foldl-atom',[->,'Expression','Atom','Variable','Variable','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(915,0),line_char(915,63))). -user:metta_file_buffer(7,322001028,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(916,1),line_char(916,2))). -user:metta_file_buffer(8,322001029,constant,'foldl-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(916,4),line_char(916,14))). -user:metta_file_buffer(8,322001029,variable,_151142,['_list'=_151142],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(916,15),line_char(916,20))). -user:metta_file_buffer(8,322001029,variable,_152426,['_init'=_152426],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(916,21),line_char(916,26))). -user:metta_file_buffer(8,322001029,variable,_153662,['_a'=_153662],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(916,27),line_char(916,29))). -user:metta_file_buffer(8,322001029,variable,_154898,['_b'=_154898],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(916,30),line_char(916,32))). -user:metta_file_buffer(8,322001029,variable,_156158,['_op'=_156158],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(916,33),line_char(916,36))). -user:metta_file_buffer(7,322001029,indexed(metta_other,['foldl-atom',_157016,_157038,_157060,_157082,_157104]),['foldl-atom',_157156,_157162,_157168,_157174,_157180],['_op'=_157180,'_b'=_157174,'_a'=_157168,'_init'=_157162,'_list'=_157156],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(916,3),line_char(916,37))). -user:metta_file_buffer(8,322001030,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(917,3),line_char(917,11))). -user:metta_file_buffer(9,322001031,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(917,13),line_char(917,17))). -user:metta_file_buffer(10,322001032,constant,'if-decons-expr',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(917,19),line_char(917,33))). -user:metta_file_buffer(10,322001032,variable,_160658,['_list'=_160658],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(917,34),line_char(917,39))). -user:metta_file_buffer(10,322001032,variable,_161942,['_head'=_161942],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(917,40),line_char(917,45))). -user:metta_file_buffer(10,322001032,variable,_163226,['_tail'=_163226],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(917,46),line_char(917,51))). -user:metta_file_buffer(11,322001033,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(918,5),line_char(918,10))). -user:metta_file_buffer(12,322001034,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(918,12),line_char(918,16))). -user:metta_file_buffer(13,322001035,constant,'atom-subst',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(918,18),line_char(918,28))). -user:metta_file_buffer(13,322001035,variable,_166902,['_init'=_166902],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(918,29),line_char(918,34))). -user:metta_file_buffer(13,322001035,variable,_168138,['_a'=_168138],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(918,35),line_char(918,37))). -user:metta_file_buffer(13,322001035,variable,_169398,['_op'=_169398],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(918,38),line_char(918,41))). -user:metta_file_buffer(12,322001035,indexed(metta_other,['atom-subst',_170244,_170266,_170288]),['atom-subst',_170340,_170346,_170352],['_op'=_170352,'_a'=_170346,'_init'=_170340],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(918,17),line_char(918,42))). -user:metta_file_buffer(11,322001035,indexed(metta_other,[eval,['atom-subst',_170914,_170936,_170958]]),[eval,['atom-subst',_171022,_171028,_171034]],['_op'=_171034,'_a'=_171028,'_init'=_171022],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(918,11),line_char(918,43))). -user:metta_file_buffer(11,322001035,variable,_172100,['_op_init'=_172100],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(918,44),line_char(918,52))). -user:metta_file_buffer(12,322001036,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(919,7),line_char(919,12))). -user:metta_file_buffer(13,322001037,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(919,14),line_char(919,18))). -user:metta_file_buffer(14,322001038,constant,'atom-subst',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(919,20),line_char(919,30))). -user:metta_file_buffer(14,322001038,variable,_175780,['_head'=_175780],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(919,31),line_char(919,36))). -user:metta_file_buffer(14,322001038,variable,_177016,['_b'=_177016],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(919,37),line_char(919,39))). -user:metta_file_buffer(14,322001038,variable,_178378,['_op_init'=_178378],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(919,40),line_char(919,48))). -user:metta_file_buffer(13,322001038,indexed(metta_other,['atom-subst',_179224,_179246,_179268]),['atom-subst',_179320,_179326,_179332],['_op_init'=_179332,'_b'=_179326,'_head'=_179320],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(919,19),line_char(919,49))). -user:metta_file_buffer(12,322001038,indexed(metta_other,[eval,['atom-subst',_179894,_179916,_179938]]),[eval,['atom-subst',_180002,_180008,_180014]],['_op_init'=_180014,'_b'=_180008,'_head'=_180002],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(919,13),line_char(919,50))). -user:metta_file_buffer(12,322001038,variable,_181080,['_op_head'=_181080],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(919,51),line_char(919,59))). -user:metta_file_buffer(13,322001039,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(920,9),line_char(920,14))). -user:metta_file_buffer(13,322001039,variable,_183254,['_op_head'=_183254],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(920,15),line_char(920,23))). -user:metta_file_buffer(13,322001039,variable,_184672,['_head_folded'=_184672],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(920,24),line_char(920,36))). -user:metta_file_buffer(14,322001040,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,11),line_char(921,16))). -user:metta_file_buffer(15,322001041,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,18),line_char(921,22))). -user:metta_file_buffer(16,322001042,constant,'foldl-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,24),line_char(921,34))). -user:metta_file_buffer(16,322001042,variable,_188360,['_tail'=_188360],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,35),line_char(921,40))). -user:metta_file_buffer(16,322001042,variable,_189778,['_head_folded'=_189778],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,41),line_char(921,53))). -user:metta_file_buffer(16,322001042,variable,_191014,['_a'=_191014],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,54),line_char(921,56))). -user:metta_file_buffer(16,322001042,variable,_192250,['_b'=_192250],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,57),line_char(921,59))). -user:metta_file_buffer(16,322001042,variable,_193510,['_op'=_193510],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,60),line_char(921,63))). -user:metta_file_buffer(15,322001042,indexed(metta_other,['foldl-atom',_194368,_194390,_194412,_194434,_194456]),['foldl-atom',_194508,_194514,_194520,_194526,_194532],['_op'=_194532,'_b'=_194526,'_a'=_194520,'_head_folded'=_194514,'_tail'=_194508],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,23),line_char(921,64))). -user:metta_file_buffer(14,322001042,indexed(metta_other,[eval,['foldl-atom',_195118,_195140,_195162,_195184,_195206]]),[eval,['foldl-atom',_195270,_195276,_195282,_195288,_195294]],['_op'=_195294,'_b'=_195288,'_a'=_195282,'_head_folded'=_195276,'_tail'=_195270],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,17),line_char(921,65))). -user:metta_file_buffer(14,322001042,variable,_196298,['_res'=_196298],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,66),line_char(921,70))). -user:metta_file_buffer(15,322001043,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,72),line_char(921,78))). -user:metta_file_buffer(15,322001043,variable,_198388,['_res'=_198388],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,79),line_char(921,83))). -user:metta_file_buffer(14,322001043,indexed(metta_other,[return,_199222]),[return,_199274],['_res'=_199274],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,71),line_char(921,84))). -user:metta_file_buffer(13,322001043,indexed(metta_other,[chain,[eval,['foldl-atom',_199840,_199862,_199884,_199906,_199928]],_199950,[return,_199950]]),[chain,[eval,['foldl-atom',_200060,_200066,_200072,_200078,_200084]],_200090,[return,_200090]],['_res'=_200090,'_op'=_200084,'_b'=_200078,'_a'=_200072,'_head_folded'=_200066,'_tail'=_200060],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(921,10),line_char(921,85))). -user:metta_file_buffer(12,322001043,indexed(metta_other,[chain,_200704,_200726,[chain,[eval,['foldl-atom',_200796,_200726,_200836,_200858,_200880]],_200902,[return,_200902]]]),[chain,_200988,_200994,[chain,[eval,['foldl-atom',_201036,_200994,_201048,_201054,_201060]],_201066,[return,_201066]]],['_res'=_201066,'_op'=_201060,'_b'=_201054,'_a'=_201048,'_tail'=_201036,'_head_folded'=_200994,'_op_head'=_200988],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(920,8),line_char(921,87))). -user:metta_file_buffer(11,322001043,indexed(metta_other,[chain,[eval,['atom-subst',_201722,_201744,_201766]],_201788,[chain,_201788,_201844,[chain,[eval,['foldl-atom',_201914,_201844,_201954,_201744,_201994]],_202016,[return,_202016]]]]),[chain,[eval,['atom-subst',_202126,_202132,_202138]],_202144,[chain,_202144,_202168,[chain,[eval,['foldl-atom',_202210,_202168,_202222,_202132,_202234]],_202240,[return,_202240]]]],['_res'=_202240,'_op'=_202234,'_a'=_202222,'_tail'=_202210,'_head_folded'=_202168,'_op_head'=_202144,'_op_init'=_202138,'_b'=_202132,'_head'=_202126],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(919,6),line_char(921,88))). -user:metta_file_buffer(10,322001043,indexed(metta_other,[chain,[eval,['atom-subst',_202920,_202942,_202964]],_202986,[chain,[eval,['atom-subst',_203056,_203078,_202986]],_203118,[chain,_203118,_203174,[chain,[eval,['foldl-atom',_203244,_203174,_202942,_203078,_202964]],_203338,[return,_203338]]]]]),[chain,[eval,['atom-subst',_203448,_203454,_203460]],_203466,[chain,[eval,['atom-subst',_203508,_203514,_203466]],_203526,[chain,_203526,_203550,[chain,[eval,['foldl-atom',_203592,_203550,_203454,_203514,_203460]],_203622,[return,_203622]]]]],['_res'=_203622,'_tail'=_203592,'_head_folded'=_203550,'_op_head'=_203526,'_b'=_203514,'_head'=_203508,'_op_init'=_203466,'_op'=_203460,'_a'=_203454,'_init'=_203448],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(918,4),line_char(921,89))). -user:metta_file_buffer(11,322001044,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(922,5),line_char(922,11))). -user:metta_file_buffer(11,322001044,variable,_205550,['_init'=_205550],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(922,12),line_char(922,17))). -user:metta_file_buffer(10,322001044,indexed(metta_other,[return,_206384]),[return,_206436],['_init'=_206436],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(922,4),line_char(922,18))). -user:metta_file_buffer(9,322001044,indexed(metta_other,['if-decons-expr',_206984,_207006,_207028,[chain,[eval,['atom-subst',_207098,_207120,_207142]],_207164,[chain,[eval,['atom-subst',_207006,_207252,_207164]],_207292,[chain,_207292,_207348,[chain,[eval,['foldl-atom',_207028,_207348,_207120,_207252,_207142]],_207508,[return,_207508]]]]],[return,_207098]]),['if-decons-expr',_207628,_207634,_207640,[chain,[eval,['atom-subst',_207682,_207688,_207694]],_207700,[chain,[eval,['atom-subst',_207634,_207748,_207700]],_207760,[chain,_207760,_207784,[chain,[eval,['foldl-atom',_207640,_207784,_207688,_207748,_207694]],_207856,[return,_207856]]]]],[return,_207682]],['_res'=_207856,'_head_folded'=_207784,'_op_head'=_207760,'_b'=_207748,'_op_init'=_207700,'_op'=_207694,'_a'=_207688,'_init'=_207682,'_tail'=_207640,'_head'=_207634,'_list'=_207628],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(917,18),line_char(922,20))). -user:metta_file_buffer(8,322001044,indexed(metta_other,[eval,['if-decons-expr',_208550,_208572,_208594,[chain,[eval,['atom-subst',_208664,_208686,_208708]],_208730,[chain,[eval,['atom-subst',_208572,_208818,_208730]],_208858,[chain,_208858,_208914,[chain,[eval,['foldl-atom',_208594,_208914,_208686,_208818,_208708]],_209074,[return,_209074]]]]],[return,_208664]]]),[eval,['if-decons-expr',_209206,_209212,_209218,[chain,[eval,['atom-subst',_209260,_209266,_209272]],_209278,[chain,[eval,['atom-subst',_209212,_209326,_209278]],_209338,[chain,_209338,_209362,[chain,[eval,['foldl-atom',_209218,_209362,_209266,_209326,_209272]],_209434,[return,_209434]]]]],[return,_209260]]],['_res'=_209434,'_head_folded'=_209362,'_op_head'=_209338,'_b'=_209326,'_op_init'=_209278,'_op'=_209272,'_a'=_209266,'_init'=_209260,'_tail'=_209218,'_head'=_209212,'_list'=_209206],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(917,12),line_char(922,21))). -user:metta_file_buffer(7,322001044,indexed(metta_other,[function,[eval,['if-decons-expr',_210144,_210166,_210188,[chain,[eval,['atom-subst',_210258,_210280,_210302]],_210324,[chain,[eval,['atom-subst',_210166,_210412,_210324]],_210452,[chain,_210452,_210508,[chain,[eval,['foldl-atom',_210188,_210508,_210280,_210412,_210302]],_210668,[return,_210668]]]]],[return,_210258]]]]),[function,[eval,['if-decons-expr',_210812,_210818,_210824,[chain,[eval,['atom-subst',_210866,_210872,_210878]],_210884,[chain,[eval,['atom-subst',_210818,_210932,_210884]],_210944,[chain,_210944,_210968,[chain,[eval,['foldl-atom',_210824,_210968,_210872,_210932,_210878]],_211040,[return,_211040]]]]],[return,_210866]]]],['_res'=_211040,'_head_folded'=_210968,'_op_head'=_210944,'_b'=_210932,'_op_init'=_210884,'_op'=_210878,'_a'=_210872,'_init'=_210866,'_tail'=_210824,'_head'=_210818,'_list'=_210812],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(917,2),line_char(922,22))). -user:metta_file_buffer(6,322001044,indexed(metta_defun,['foldl-atom',_211740,_211762,_211784,_211806,_211828]),[=,['foldl-atom',_212534,_212540,_212546,_212552,_212558],[function,[eval,['if-decons-expr',_212534,_212606,_212612,[chain,[eval,['atom-subst',_212540,_212546,_212558]],_212672,[chain,[eval,['atom-subst',_212606,_212552,_212672]],_212732,[chain,_212732,_212756,[chain,[eval,['foldl-atom',_212612,_212756,_212546,_212552,_212558]],_212828,[return,_212828]]]]],[return,_212540]]]]],['_res'=_212828,'_head_folded'=_212756,'_op_head'=_212732,'_op_init'=_212672,'_tail'=_212612,'_head'=_212606,'_op'=_212558,'_b'=_212552,'_a'=_212546,'_init'=_212540,'_list'=_212534],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(916,0),line_char(922,23))). -user:metta_file_buffer(7,323001045,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(924,1),line_char(924,3))). -user:metta_file_buffer(7,323001045,constant,'separate-errors',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(924,4),line_char(924,19))). -user:metta_file_buffer(7,323001045,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(924,20),line_char(924,38))). -user:metta_file_buffer(6,323001045,metta_other,[iz,'separate-errors','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(924,0),line_char(924,39))). -user:metta_file_buffer(7,324001046,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(925,1),line_char(925,2))). -user:metta_file_buffer(7,324001046,constant,'separate-errors',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(925,3),line_char(925,18))). -user:metta_file_buffer(8,324001047,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(925,20),line_char(925,22))). -user:metta_file_buffer(8,324001047,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(925,23),line_char(925,33))). -user:metta_file_buffer(8,324001047,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(925,34),line_char(925,44))). -user:metta_file_buffer(8,324001047,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(925,45),line_char(925,55))). -user:metta_file_buffer(7,324001047,metta_other,[->,'Expression','Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(925,19),line_char(925,56))). -user:metta_file_buffer(6,324001047,metta_typedecl,[:,'separate-errors',[->,'Expression','Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(925,0),line_char(925,57))). -user:metta_file_buffer(7,325001048,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(926,1),line_char(926,2))). -user:metta_file_buffer(8,325001049,constant,'separate-errors',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(926,4),line_char(926,19))). -user:metta_file_buffer(8,325001049,variable,_151278,['_succ_err'=_151278],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(926,20),line_char(926,29))). -user:metta_file_buffer(8,325001049,variable,_152554,['_res'=_152554],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(926,30),line_char(926,34))). -user:metta_file_buffer(7,325001049,indexed(metta_other,['separate-errors',_153394,_153416]),['separate-errors',_153468,_153474],['_res'=_153474,'_succ_err'=_153468],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(926,3),line_char(926,35))). -user:metta_file_buffer(8,325001050,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(927,3),line_char(927,11))). -user:metta_file_buffer(9,325001051,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(927,13),line_char(927,21))). -user:metta_file_buffer(9,325001051,variable,_156148,['_succ_err'=_156148],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(927,22),line_char(927,31))). -user:metta_file_buffer(10,325001052,variable,_157554,['_suc'=_157554],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(927,33),line_char(927,37))). -user:metta_file_buffer(10,325001052,variable,_158830,['_err'=_158830],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(927,38),line_char(927,42))). -user:metta_file_buffer(9,325001052,indexed(metta_other,[_159656,_159678]),[_159724,_159730],['_err'=_159730,'_suc'=_159724],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(927,32),line_char(927,43))). -user:metta_file_buffer(10,325001053,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(928,5),line_char(928,13))). -user:metta_file_buffer(10,325001053,variable,_161472,['_res'=_161472],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(928,14),line_char(928,18))). -user:metta_file_buffer(11,325001054,variable,_162846,['_a'=_162846],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(928,20),line_char(928,22))). -user:metta_file_buffer(11,325001054,variable,_163810,['_b'=_163810],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(928,23),line_char(928,26))). -user:metta_file_buffer(10,325001054,indexed(metta_other,[_164636,_164658]),[_164704,_164710],['_b'=_164710,'_a'=_164704],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(928,19),line_char(928,27))). -user:metta_file_buffer(11,325001055,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(929,7),line_char(929,11))). -user:metta_file_buffer(12,325001056,constant,'if-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(929,13),line_char(929,21))). -user:metta_file_buffer(12,325001056,variable,_167218,['_a'=_167218],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(929,22),line_char(929,24))). -user:metta_file_buffer(13,325001057,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(930,9),line_char(930,14))). -user:metta_file_buffer(14,325001058,constant,'cons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(930,16),line_char(930,25))). -user:metta_file_buffer(14,325001058,variable,_170082,['_res'=_170082],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(930,26),line_char(930,30))). -user:metta_file_buffer(14,325001058,variable,_171358,['_err'=_171358],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(930,31),line_char(930,35))). -user:metta_file_buffer(13,325001058,indexed(metta_other,['cons-atom',_172198,_172220]),['cons-atom',_172272,_172278],['_err'=_172278,'_res'=_172272],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(930,15),line_char(930,36))). -user:metta_file_buffer(14,326001059,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(930,44),line_char(930,50))). -user:metta_file_buffer(15,326001060,variable,_175100,['_suc'=_175100],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(930,52),line_char(930,56))). -user:metta_file_buffer(15,327001060,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(930,62),line_char(930,63))). -user:metta_file_buffer(15,328001060,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(930,63),line_char(930,64))). -user:metta_file_buffer(15,329001060,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(930,64),line_char(930,65))). -user:metta_file_buffer(16,330001061,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(931,9),line_char(931,14))). -user:metta_file_buffer(17,330001062,constant,'cons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(931,16),line_char(931,25))). -user:metta_file_buffer(17,330001062,variable,_179826,['_res'=_179826],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(931,26),line_char(931,30))). -user:metta_file_buffer(17,330001062,variable,_181102,['_suc'=_181102],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(931,31),line_char(931,35))). -user:metta_file_buffer(16,330001062,indexed(metta_other,['cons-atom',_181942,_181964]),['cons-atom',_182016,_182022],['_suc'=_182022,'_res'=_182016],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(931,15),line_char(931,36))). -user:metta_file_buffer(17,331001063,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(931,44),line_char(931,50))). -user:metta_file_buffer(18,332001064,variable,_185754,['_err'=_185754],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(931,58),line_char(931,62))). -user:metta_file_buffer(18,333001064,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(931,62),line_char(931,63))). -user:metta_file_buffer(18,334001064,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(931,63),line_char(931,64))). -user:metta_file_buffer(18,335001064,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(931,64),line_char(931,65))). -user:metta_file_buffer(18,336001064,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(931,66),line_char(931,67))). -user:metta_file_buffer(18,337001064,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(931,67),line_char(931,68))). -user:metta_file_buffer(19,338001065,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(932,7),line_char(932,13))). -user:metta_file_buffer(19,338001065,variable,_188268,['_succ_err'=_188268],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(932,14),line_char(932,23))). -user:metta_file_buffer(18,338001065,indexed(metta_other,[return,_189102]),[return,_189154],['_succ_err'=_189154],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(932,6),line_char(932,24))). -user:metta_file_buffer(18,339001065,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(932,24),line_char(932,25))). -user:metta_file_buffer(19,340001066,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(933,5),line_char(933,11))). -user:metta_file_buffer(19,340001066,variable,_188576,['_succ_err'=_188576],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(933,12),line_char(933,21))). -user:metta_file_buffer(18,340001066,indexed(metta_other,[return,_189410]),[return,_189462],['_succ_err'=_189462],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(933,4),line_char(933,22))). -user:metta_file_buffer(18,341001066,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(933,23),line_char(933,24))). -user:metta_file_buffer(18,342001066,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(933,24),line_char(933,25))). -user:metta_file_buffer(18,343001066,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(933,25),line_char(933,26))). -user:metta_file_buffer(19,344001067,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(935,1),line_char(935,3))). -user:metta_file_buffer(19,344001067,constant,'check-alternatives',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(935,4),line_char(935,22))). -user:metta_file_buffer(19,344001067,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(935,23),line_char(935,41))). -user:metta_file_buffer(18,344001067,metta_other,[iz,'check-alternatives','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(935,0),line_char(935,42))). -user:metta_file_buffer(19,345001068,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(936,1),line_char(936,2))). -user:metta_file_buffer(20,345001069,constant,'check-alternatives',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(936,4),line_char(936,22))). -user:metta_file_buffer(20,345001069,variable,_190252,['_atom'=_190252],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(936,23),line_char(936,28))). -user:metta_file_buffer(19,345001069,indexed(metta_other,['check-alternatives',_191086]),['check-alternatives',_191138],['_atom'=_191138],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(936,3),line_char(936,29))). -user:metta_file_buffer(20,345001070,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(937,3),line_char(937,11))). -user:metta_file_buffer(21,345001071,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(938,5),line_char(938,10))). -user:metta_file_buffer(22,345001072,constant,'collapse-bind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(938,12),line_char(938,25))). -user:metta_file_buffer(22,345001072,variable,_194584,['_atom'=_194584],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(938,26),line_char(938,31))). -user:metta_file_buffer(21,345001072,indexed(metta_other,['collapse-bind',_195418]),['collapse-bind',_195470],['_atom'=_195470],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(938,11),line_char(938,32))). -user:metta_file_buffer(21,345001072,variable,_196538,['_collapsed'=_196538],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(938,33),line_char(938,43))). -user:metta_file_buffer(21,345001072,indexed(metta_comment,";(chain (eval (print-alternatives! $atom $collapsed)) $_"),'$COMMENT'(";(chain (eval (print-alternatives! $atom $collapsed)) $_",939,6),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(939,6),line_char(939,62))). -user:metta_file_buffer(22,345001073,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(940,7),line_char(940,12))). -user:metta_file_buffer(23,345001074,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(940,14),line_char(940,18))). -user:metta_file_buffer(24,345001075,constant,'foldl-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(940,20),line_char(940,30))). -user:metta_file_buffer(24,345001075,variable,_200938,['_collapsed'=_200938],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(940,31),line_char(940,41))). -user:metta_file_buffer(25,345001077,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(940,43),line_char(940,45))). -user:metta_file_buffer(25,345001078,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(940,46),line_char(940,48))). -user:metta_file_buffer(24,345001078,metta_other,[[],[]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(940,42),line_char(940,49))). -user:metta_file_buffer(24,345001078,variable,_204278,['_succ_err'=_204278],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(940,50),line_char(940,59))). -user:metta_file_buffer(24,345001078,variable,_205546,['_res'=_205546],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(940,60),line_char(940,64))). -user:metta_file_buffer(25,345001079,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(941,9),line_char(941,13))). -user:metta_file_buffer(26,345001080,constant,'separate-errors',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(941,15),line_char(941,30))). -user:metta_file_buffer(26,345001080,variable,_208562,['_succ_err'=_208562],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(941,31),line_char(941,40))). -user:metta_file_buffer(26,345001080,variable,_209838,['_res'=_209838],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(941,41),line_char(941,45))). -user:metta_file_buffer(25,345001080,indexed(metta_other,['separate-errors',_210678,_210700]),['separate-errors',_210752,_210758],['_res'=_210758,'_succ_err'=_210752],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(941,14),line_char(941,46))). -user:metta_file_buffer(24,345001080,indexed(metta_other,[eval,['separate-errors',_211308,_211330]]),[eval,['separate-errors',_211394,_211400]],['_res'=_211400,'_succ_err'=_211394],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(941,8),line_char(941,47))). -user:metta_file_buffer(23,345001080,indexed(metta_other,['foldl-atom',_211958,[[],[]],_212004,_212026,[eval,['separate-errors',_212004,_212026]]]),['foldl-atom',_212146,[[],[]],_212158,_212164,[eval,['separate-errors',_212158,_212164]]],['_res'=_212164,'_succ_err'=_212158,'_collapsed'=_212146],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(940,19),line_char(941,48))). -user:metta_file_buffer(22,345001080,indexed(metta_other,[eval,['foldl-atom',_212762,[[],[]],_212808,_212830,[eval,['separate-errors',_212808,_212830]]]]),[eval,['foldl-atom',_212962,[[],[]],_212974,_212980,[eval,['separate-errors',_212974,_212980]]]],['_res'=_212980,'_succ_err'=_212974,'_collapsed'=_212962],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(940,13),line_char(941,49))). -user:metta_file_buffer(22,345001080,variable,_214108,['_separated'=_214108],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(941,50),line_char(941,60))). -user:metta_file_buffer(23,345001081,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(942,9),line_char(942,17))). -user:metta_file_buffer(23,345001081,variable,_216270,['_separated'=_216270],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(942,18),line_char(942,28))). -user:metta_file_buffer(24,345001082,variable,_217756,['_success'=_217756],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(942,30),line_char(942,38))). -user:metta_file_buffer(24,345001082,variable,_219064,['_error'=_219064],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(942,39),line_char(942,45))). -user:metta_file_buffer(23,345001082,indexed(metta_other,[_219890,_219912]),[_219958,_219964],['_error'=_219964,'_success'=_219958],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(942,29),line_char(942,46))). -user:metta_file_buffer(24,345001083,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(943,11),line_char(943,16))). -user:metta_file_buffer(25,345001084,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(943,18),line_char(943,22))). -user:metta_file_buffer(26,345001085,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(943,24),line_char(943,32))). -user:metta_file_buffer(26,345001085,variable,_223396,['_success'=_223396],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(943,33),line_char(943,41))). -user:metta_file_buffer(26,345001086,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(943,42),line_char(943,44))). -user:metta_file_buffer(26,345001086,variable,_225344,['_error'=_225344],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(943,45),line_char(943,51))). -user:metta_file_buffer(26,345001086,variable,_226700,['_success'=_226700],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(943,52),line_char(943,60))). -user:metta_file_buffer(25,345001086,indexed(metta_other,['if-equal',_227552,[],_227582,_227552]),['if-equal',_227652,[],_227664,_227652],['_error'=_227664,'_success'=_227652],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(943,23),line_char(943,61))). -user:metta_file_buffer(24,345001086,indexed(metta_other,[eval,['if-equal',_228220,[],_228250,_228220]]),[eval,['if-equal',_228332,[],_228344,_228332]],['_error'=_228344,'_success'=_228332],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(943,17),line_char(943,62))). -user:metta_file_buffer(24,345001086,variable,_229414,['_filtered'=_229414],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(943,63),line_char(943,72))). -user:metta_file_buffer(25,345001087,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(944,13),line_char(944,18))). -user:metta_file_buffer(26,345001088,constant,'superpose-bind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(944,20),line_char(944,34))). -user:metta_file_buffer(26,345001088,variable,_232440,['_filtered'=_232440],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(944,35),line_char(944,44))). -user:metta_file_buffer(25,345001088,indexed(metta_other,['superpose-bind',_233274]),['superpose-bind',_233326],['_filtered'=_233326],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(944,19),line_char(944,45))). -user:metta_file_buffer(25,345001088,variable,_234282,['_ret'=_234282],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(944,46),line_char(944,50))). -user:metta_file_buffer(26,345001089,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(944,52),line_char(944,58))). -user:metta_file_buffer(26,345001089,variable,_236372,['_ret'=_236372],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(944,59),line_char(944,63))). -user:metta_file_buffer(25,345001089,indexed(metta_other,[return,_237206]),[return,_237258],['_ret'=_237258],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(944,51),line_char(944,64))). -user:metta_file_buffer(24,345001089,indexed(metta_other,[chain,['superpose-bind',_237808],_237830,[return,_237830]]),[chain,['superpose-bind',_237928],_237934,[return,_237934]],['_ret'=_237934,'_filtered'=_237928],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(944,12),line_char(944,65))). -user:metta_file_buffer(23,345001089,indexed(metta_other,[chain,[eval,['if-equal',_238532,[],_238562,_238532]],_238602,[chain,['superpose-bind',_238602],_238674,[return,_238674]]]),[chain,[eval,['if-equal',_238784,[],_238796,_238784]],_238808,[chain,['superpose-bind',_238808],_238844,[return,_238844]]],['_ret'=_238844,'_filtered'=_238808,'_error'=_238796,'_success'=_238784],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(943,10),line_char(944,67))). -user:metta_file_buffer(24,345001090,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(945,11),line_char(945,17))). -user:metta_file_buffer(25,345001091,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(945,19),line_char(945,24))). -user:metta_file_buffer(26,345001092,constant,'check-alternatives',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(945,26),line_char(945,44))). -user:metta_file_buffer(26,345001092,variable,_242314,['_atom'=_242314],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(945,45),line_char(945,50))). -user:metta_file_buffer(25,345001092,indexed(metta_other,['check-alternatives',_243148]),['check-alternatives',_243200],['_atom'=_243200],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(945,25),line_char(945,51))). -user:metta_file_buffer(25,345001092,string,"list of results was not filtered correctly",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(945,52),line_char(945,96))). -user:metta_file_buffer(24,345001092,indexed(metta_other,['Error',['check-alternatives',_244730],"list of results was not filtered correctly"]),['Error',['check-alternatives',_244802],"list of results was not filtered correctly"],['_atom'=_244802],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(945,18),line_char(945,97))). -user:metta_file_buffer(23,345001092,indexed(metta_other,[return,['Error',['check-alternatives',_245356],"list of results was not filtered correctly"]]),[return,['Error',['check-alternatives',_245440],"list of results was not filtered correctly"]],['_atom'=_245440],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(945,10),line_char(945,98))). -user:metta_file_buffer(22,345001092,indexed(metta_other,['if-unify',_245982,[_246012,_246034],[chain,[eval,['if-equal',_246012,[],_246034,_246012]],_246166,[chain,['superpose-bind',_246166],_246238,[return,_246238]]],[return,['Error',['check-alternatives',_246342],"list of results was not filtered correctly"]]]),['if-unify',_246402,[_246414,_246420],[chain,[eval,['if-equal',_246414,[],_246420,_246414]],_246486,[chain,['superpose-bind',_246486],_246522,[return,_246522]]],[return,['Error',['check-alternatives',_246582],"list of results was not filtered correctly"]]],['_atom'=_246582,'_ret'=_246522,'_filtered'=_246486,'_error'=_246420,'_success'=_246414,'_separated'=_246402],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(942,8),line_char(945,100))). -user:metta_file_buffer(21,345001092,indexed(metta_other,[chain,[eval,['foldl-atom',_247208,[[],[]],_247254,_247276,[eval,['separate-errors',_247254,_247276]]]],_247366,['if-unify',_247366,[_247430,_247452],[chain,[eval,['if-equal',_247430,[],_247452,_247430]],_247584,[chain,['superpose-bind',_247584],_247656,[return,_247656]]],[return,['Error',['check-alternatives',_247760],"list of results was not filtered correctly"]]]]),[chain,[eval,['foldl-atom',_247844,[[],[]],_247856,_247862,[eval,['separate-errors',_247856,_247862]]]],_247904,['if-unify',_247904,[_247934,_247940],[chain,[eval,['if-equal',_247934,[],_247940,_247934]],_248006,[chain,['superpose-bind',_248006],_248042,[return,_248042]]],[return,['Error',['check-alternatives',_248102],"list of results was not filtered correctly"]]]],['_atom'=_248102,'_ret'=_248042,'_filtered'=_248006,'_error'=_247940,'_success'=_247934,'_separated'=_247904,'_res'=_247862,'_succ_err'=_247856,'_collapsed'=_247844],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(940,6),line_char(945,101))). -user:metta_file_buffer(20,345001092,indexed(metta_other,[chain,['collapse-bind',_248748],_248770,[chain,[eval,['foldl-atom',_248770,[[],[]],_248882,_248904,[eval,['separate-errors',_248882,_248904]]]],_248994,['if-unify',_248994,[_249058,_249080],[chain,[eval,['if-equal',_249058,[],_249080,_249058]],_249212,[chain,['superpose-bind',_249212],_249284,[return,_249284]]],[return,['Error',['check-alternatives',_248748],"list of results was not filtered correctly"]]]]]),[chain,['collapse-bind',_249456],_249462,[chain,[eval,['foldl-atom',_249462,[[],[]],_249516,_249522,[eval,['separate-errors',_249516,_249522]]]],_249564,['if-unify',_249564,[_249594,_249600],[chain,[eval,['if-equal',_249594,[],_249600,_249594]],_249666,[chain,['superpose-bind',_249666],_249702,[return,_249702]]],[return,['Error',['check-alternatives',_249456],"list of results was not filtered correctly"]]]]],['_ret'=_249702,'_filtered'=_249666,'_error'=_249600,'_success'=_249594,'_separated'=_249564,'_res'=_249522,'_succ_err'=_249516,'_collapsed'=_249462,'_atom'=_249456],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(938,4),line_char(945,102))). -user:metta_file_buffer(19,345001092,indexed(metta_other,[function,[chain,['collapse-bind',_250412],_250434,[chain,[eval,['foldl-atom',_250434,[[],[]],_250546,_250568,[eval,['separate-errors',_250546,_250568]]]],_250658,['if-unify',_250658,[_250722,_250744],[chain,[eval,['if-equal',_250722,[],_250744,_250722]],_250876,[chain,['superpose-bind',_250876],_250948,[return,_250948]]],[return,['Error',['check-alternatives',_250412],"list of results was not filtered correctly"]]]]]]),[function,[chain,['collapse-bind',_251132],_251138,[chain,[eval,['foldl-atom',_251138,[[],[]],_251192,_251198,[eval,['separate-errors',_251192,_251198]]]],_251240,['if-unify',_251240,[_251270,_251276],[chain,[eval,['if-equal',_251270,[],_251276,_251270]],_251342,[chain,['superpose-bind',_251342],_251378,[return,_251378]]],[return,['Error',['check-alternatives',_251132],"list of results was not filtered correctly"]]]]]],['_ret'=_251378,'_filtered'=_251342,'_error'=_251276,'_success'=_251270,'_separated'=_251240,'_res'=_251198,'_succ_err'=_251192,'_collapsed'=_251138,'_atom'=_251132],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(937,2),line_char(945,103))). -user:metta_file_buffer(18,345001092,indexed(metta_defun,['check-alternatives',_252078]),[=,['check-alternatives',_252852],[function,[chain,['collapse-bind',_252852],_252900,[chain,[eval,['foldl-atom',_252900,[[],[]],_252954,_252960,[eval,['separate-errors',_252954,_252960]]]],_253002,['if-unify',_253002,[_253032,_253038],[chain,[eval,['if-equal',_253032,[],_253038,_253032]],_253104,[chain,['superpose-bind',_253104],_253140,[return,_253140]]],[return,['Error',['check-alternatives',_252852],"list of results was not filtered correctly"]]]]]]],['_ret'=_253140,'_filtered'=_253104,'_error'=_253038,'_success'=_253032,'_separated'=_253002,'_res'=_252960,'_succ_err'=_252954,'_collapsed'=_252900,'_atom'=_252852],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(936,0),line_char(945,104))). -user:metta_file_buffer(19,346001093,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(947,1),line_char(947,3))). -user:metta_file_buffer(19,346001093,constant,interpret,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(947,4),line_char(947,13))). -user:metta_file_buffer(19,346001093,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(947,14),line_char(947,19))). -user:metta_file_buffer(18,346001093,metta_other,[iz,interpret,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(947,0),line_char(947,20))). -user:metta_file_buffer(19,347001094,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(948,1),line_char(948,2))). -user:metta_file_buffer(20,347001095,constant,interpret,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(948,4),line_char(948,13))). -user:metta_file_buffer(20,347001095,variable,_190222,['_atom'=_190222],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(948,14),line_char(948,19))). -user:metta_file_buffer(20,347001095,variable,_191506,['_type'=_191506],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(948,20),line_char(948,25))). -user:metta_file_buffer(20,347001095,variable,_192814,['_space'=_192814],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(948,26),line_char(948,32))). -user:metta_file_buffer(19,347001095,indexed(metta_other,[interpret,_193660,_193682,_193704]),[interpret,_193756,_193762,_193768],['_space'=_193768,'_type'=_193762,'_atom'=_193756],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(948,3),line_char(948,33))). -user:metta_file_buffer(20,347001096,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(949,3),line_char(949,11))). -user:metta_file_buffer(21,347001097,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(949,13),line_char(949,18))). -user:metta_file_buffer(22,347001098,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(949,20),line_char(949,24))). -user:metta_file_buffer(23,347001099,constant,'get-metatype',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(949,26),line_char(949,38))). -user:metta_file_buffer(23,347001099,variable,_198014,['_atom'=_198014],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(949,39),line_char(949,44))). -user:metta_file_buffer(22,347001099,indexed(metta_other,['get-metatype',_198848]),['get-metatype',_198900],['_atom'=_198900],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(949,25),line_char(949,45))). -user:metta_file_buffer(21,347001099,indexed(metta_other,[eval,['get-metatype',_199438]]),[eval,['get-metatype',_199502]],['_atom'=_199502],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(949,19),line_char(949,46))). -user:metta_file_buffer(21,347001099,variable,_200474,['_meta'=_200474],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(949,47),line_char(949,52))). -user:metta_file_buffer(22,347001100,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(950,5),line_char(950,9))). -user:metta_file_buffer(23,347001101,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(950,11),line_char(950,19))). -user:metta_file_buffer(23,347001101,variable,_203326,['_type'=_203326],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(950,20),line_char(950,25))). -user:metta_file_buffer(23,347001101,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(950,26),line_char(950,30))). -user:metta_file_buffer(24,347001102,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(951,7),line_char(951,13))). -user:metta_file_buffer(24,347001102,variable,_206032,['_atom'=_206032],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(951,14),line_char(951,19))). -user:metta_file_buffer(23,347001102,indexed(metta_other,[return,_206866]),[return,_206918],['_atom'=_206918],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(951,6),line_char(951,20))). -user:metta_file_buffer(24,347001103,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(952,7),line_char(952,11))). -user:metta_file_buffer(25,347001104,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(952,13),line_char(952,21))). -user:metta_file_buffer(25,347001104,variable,_209462,['_type'=_209462],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(952,22),line_char(952,27))). -user:metta_file_buffer(25,347001104,variable,_210746,['_meta'=_210746],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(952,28),line_char(952,33))). -user:metta_file_buffer(26,347001105,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(953,9),line_char(953,15))). -user:metta_file_buffer(26,347001105,variable,_212868,['_atom'=_212868],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(953,16),line_char(953,21))). -user:metta_file_buffer(25,347001105,indexed(metta_other,[return,_213702]),[return,_213754],['_atom'=_213754],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(953,8),line_char(953,22))). -user:metta_file_buffer(26,347001106,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(954,9),line_char(954,13))). -user:metta_file_buffer(27,347001107,constant,switch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(954,15),line_char(954,21))). -user:metta_file_buffer(28,347001108,variable,_216488,['_type'=_216488],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(954,23),line_char(954,28))). -user:metta_file_buffer(28,347001108,variable,_217780,['_meta'=_217780],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(954,29),line_char(954,34))). -user:metta_file_buffer(27,347001108,indexed(metta_other,[_218606,_218628]),[_218674,_218680],['_meta'=_218680,'_type'=_218674],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(954,22),line_char(954,35))). -user:metta_file_buffer(30,347001111,variable,_220100,['_type'=_220100],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(955,12),line_char(955,17))). -user:metta_file_buffer(30,347001111,constant,'Variable',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(955,18),line_char(955,26))). -user:metta_file_buffer(29,347001111,indexed(metta_other,[_221562,'Variable']),[_221616,'Variable'],['_type'=_221616],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(955,11),line_char(955,27))). -user:metta_file_buffer(30,347001112,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(955,29),line_char(955,35))). -user:metta_file_buffer(30,347001112,variable,_223410,['_atom'=_223410],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(955,36),line_char(955,41))). -user:metta_file_buffer(29,347001112,indexed(metta_other,[return,_224244]),[return,_224296],['_atom'=_224296],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(955,28),line_char(955,42))). -user:metta_file_buffer(28,347001112,indexed(array,[[_224818,'Variable'],[return,_224864]]),[[_224916,'Variable'],[return,_224934]],['_atom'=_224934,'_type'=_224916],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(955,10),line_char(955,43))). -user:metta_file_buffer(30,347001114,variable,_226220,['_type'=_226220],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(956,12),line_char(956,17))). -user:metta_file_buffer(30,347001114,constant,'Symbol',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(956,18),line_char(956,24))). -user:metta_file_buffer(29,347001114,indexed(metta_other,[_227662,'Symbol']),[_227716,'Symbol'],['_type'=_227716],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(956,11),line_char(956,25))). -user:metta_file_buffer(30,347001115,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,13),line_char(957,18))). -user:metta_file_buffer(31,347001116,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,20),line_char(957,24))). -user:metta_file_buffer(32,347001117,constant,'type-cast',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,26),line_char(957,35))). -user:metta_file_buffer(32,347001117,variable,_231086,['_atom'=_231086],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,36),line_char(957,41))). -user:metta_file_buffer(32,347001117,variable,_232370,['_type'=_232370],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,42),line_char(957,47))). -user:metta_file_buffer(32,347001117,variable,_233678,['_space'=_233678],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,48),line_char(957,54))). -user:metta_file_buffer(31,347001117,indexed(metta_other,['type-cast',_234524,_234546,_234568]),['type-cast',_234620,_234626,_234632],['_space'=_234632,'_type'=_234626,'_atom'=_234620],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,25),line_char(957,55))). -user:metta_file_buffer(30,347001117,indexed(metta_other,[eval,['type-cast',_235194,_235216,_235238]]),[eval,['type-cast',_235302,_235308,_235314]],['_space'=_235314,'_type'=_235308,'_atom'=_235302],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,19),line_char(957,56))). -user:metta_file_buffer(30,347001117,variable,_236294,['_ret'=_236294],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,57),line_char(957,61))). -user:metta_file_buffer(31,347001118,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,63),line_char(957,69))). -user:metta_file_buffer(31,347001118,variable,_238384,['_ret'=_238384],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,70),line_char(957,74))). -user:metta_file_buffer(30,347001118,indexed(metta_other,[return,_239218]),[return,_239270],['_ret'=_239270],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,62),line_char(957,75))). -user:metta_file_buffer(29,347001118,indexed(metta_other,[chain,[eval,['type-cast',_239836,_239858,_239880]],_239902,[return,_239902]]),[chain,[eval,['type-cast',_240012,_240018,_240024]],_240030,[return,_240030]],['_ret'=_240030,'_space'=_240024,'_type'=_240018,'_atom'=_240012],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(957,12),line_char(957,76))). -user:metta_file_buffer(28,347001118,indexed(array,[[_240606,'Symbol'],[chain,[eval,['type-cast',_240684,_240606,_240724]],_240746,[return,_240746]]]),[[_240832,'Symbol'],[chain,[eval,['type-cast',_240874,_240832,_240886]],_240892,[return,_240892]]],['_ret'=_240892,'_space'=_240886,'_atom'=_240874,'_type'=_240832],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(956,10),line_char(957,77))). -user:metta_file_buffer(30,347001120,variable,_242220,['_type'=_242220],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(958,12),line_char(958,17))). -user:metta_file_buffer(30,347001120,constant,'Grounded',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(958,18),line_char(958,26))). -user:metta_file_buffer(29,347001120,indexed(metta_other,[_243682,'Grounded']),[_243736,'Grounded'],['_type'=_243736],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(958,11),line_char(958,27))). -user:metta_file_buffer(30,347001121,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,13),line_char(959,18))). -user:metta_file_buffer(31,347001122,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,20),line_char(959,24))). -user:metta_file_buffer(32,347001123,constant,'type-cast',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,26),line_char(959,35))). -user:metta_file_buffer(32,347001123,variable,_247106,['_atom'=_247106],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,36),line_char(959,41))). -user:metta_file_buffer(32,347001123,variable,_248390,['_type'=_248390],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,42),line_char(959,47))). -user:metta_file_buffer(32,347001123,variable,_249698,['_space'=_249698],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,48),line_char(959,54))). -user:metta_file_buffer(31,347001123,indexed(metta_other,['type-cast',_250544,_250566,_250588]),['type-cast',_250640,_250646,_250652],['_space'=_250652,'_type'=_250646,'_atom'=_250640],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,25),line_char(959,55))). -user:metta_file_buffer(30,347001123,indexed(metta_other,[eval,['type-cast',_251214,_251236,_251258]]),[eval,['type-cast',_251322,_251328,_251334]],['_space'=_251334,'_type'=_251328,'_atom'=_251322],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,19),line_char(959,56))). -user:metta_file_buffer(30,347001123,variable,_252314,['_ret'=_252314],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,57),line_char(959,61))). -user:metta_file_buffer(31,347001124,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,63),line_char(959,69))). -user:metta_file_buffer(31,347001124,variable,_254404,['_ret'=_254404],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,70),line_char(959,74))). -user:metta_file_buffer(30,347001124,indexed(metta_other,[return,_255238]),[return,_255290],['_ret'=_255290],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,62),line_char(959,75))). -user:metta_file_buffer(29,347001124,indexed(metta_other,[chain,[eval,['type-cast',_255856,_255878,_255900]],_255922,[return,_255922]]),[chain,[eval,['type-cast',_256032,_256038,_256044]],_256050,[return,_256050]],['_ret'=_256050,'_space'=_256044,'_type'=_256038,'_atom'=_256032],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(959,12),line_char(959,76))). -user:metta_file_buffer(28,347001124,indexed(array,[[_256626,'Grounded'],[chain,[eval,['type-cast',_256704,_256626,_256744]],_256766,[return,_256766]]]),[[_256852,'Grounded'],[chain,[eval,['type-cast',_256894,_256852,_256906]],_256912,[return,_256912]]],['_ret'=_256912,'_space'=_256906,'_atom'=_256894,'_type'=_256852],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(958,10),line_char(959,77))). -user:metta_file_buffer(30,347001126,variable,_258240,['_type'=_258240],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(960,12),line_char(960,17))). -user:metta_file_buffer(30,347001126,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(960,18),line_char(960,28))). -user:metta_file_buffer(29,347001126,indexed(metta_other,[_259722,'Expression']),[_259776,'Expression'],['_type'=_259776],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(960,11),line_char(960,29))). -user:metta_file_buffer(30,347001127,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,13),line_char(961,18))). -user:metta_file_buffer(31,347001128,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,20),line_char(961,24))). -user:metta_file_buffer(32,347001129,constant,'check-alternatives',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,26),line_char(961,44))). -user:metta_file_buffer(33,347001130,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,46),line_char(961,50))). -user:metta_file_buffer(34,347001131,constant,'interpret-expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,52),line_char(961,72))). -user:metta_file_buffer(34,347001131,variable,_264916,['_atom'=_264916],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,73),line_char(961,78))). -user:metta_file_buffer(34,347001131,variable,_266200,['_type'=_266200],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,79),line_char(961,84))). -user:metta_file_buffer(34,347001131,variable,_267508,['_space'=_267508],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,85),line_char(961,91))). -user:metta_file_buffer(33,347001131,indexed(metta_other,['interpret-expression',_268354,_268376,_268398]),['interpret-expression',_268450,_268456,_268462],['_space'=_268462,'_type'=_268456,'_atom'=_268450],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,51),line_char(961,92))). -user:metta_file_buffer(32,347001131,indexed(metta_other,[eval,['interpret-expression',_269024,_269046,_269068]]),[eval,['interpret-expression',_269132,_269138,_269144]],['_space'=_269144,'_type'=_269138,'_atom'=_269132],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,45),line_char(961,93))). -user:metta_file_buffer(31,347001131,indexed(metta_other,['check-alternatives',[eval,['interpret-expression',_269722,_269744,_269766]]]),['check-alternatives',[eval,['interpret-expression',_269842,_269848,_269854]]],['_space'=_269854,'_type'=_269848,'_atom'=_269842],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,25),line_char(961,94))). -user:metta_file_buffer(30,347001131,indexed(metta_other,[eval,['check-alternatives',[eval,['interpret-expression',_270448,_270470,_270492]]]]),[eval,['check-alternatives',[eval,['interpret-expression',_270580,_270586,_270592]]]],['_space'=_270592,'_type'=_270586,'_atom'=_270580],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,19),line_char(961,95))). -user:metta_file_buffer(30,347001131,variable,_271572,['_ret'=_271572],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,96),line_char(961,100))). -user:metta_file_buffer(31,347001132,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,102),line_char(961,108))). -user:metta_file_buffer(31,347001132,variable,_273662,['_ret'=_273662],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,109),line_char(961,113))). -user:metta_file_buffer(30,347001132,indexed(metta_other,[return,_274496]),[return,_274548],['_ret'=_274548],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,101),line_char(961,114))). -user:metta_file_buffer(29,347001132,indexed(metta_other,[chain,[eval,['check-alternatives',[eval,['interpret-expression',_275146,_275168,_275190]]]],_275212,[return,_275212]]),[chain,[eval,['check-alternatives',[eval,['interpret-expression',_275346,_275352,_275358]]]],_275364,[return,_275364]],['_ret'=_275364,'_space'=_275358,'_type'=_275352,'_atom'=_275346],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(961,12),line_char(961,115))). -user:metta_file_buffer(28,347001132,indexed(array,[[_275940,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_276050,_275940,_276090]]]],_276112,[return,_276112]]]),[[_276198,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_276264,_276198,_276276]]]],_276282,[return,_276282]]],['_ret'=_276282,'_space'=_276276,'_atom'=_276264,'_type'=_276198],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(960,10),line_char(961,116))). -user:metta_file_buffer(27,347001132,indexed(array,[[[_276902,'Variable'],[return,_276948]],[[_276902,'Symbol'],[chain,[eval,['type-cast',_276948,_276902,_277096]],_277118,[return,_277118]]],[[_276902,'Grounded'],[chain,[eval,['type-cast',_276948,_276902,_277096]],_277118,[return,_277118]]],[[_276902,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_276948,_276902,_277096]]]],_277118,[return,_277118]]]]),[[[_277634,'Variable'],[return,_277652]],[[_277634,'Symbol'],[chain,[eval,['type-cast',_277652,_277634,_277724]],_277730,[return,_277730]]],[[_277634,'Grounded'],[chain,[eval,['type-cast',_277652,_277634,_277724]],_277730,[return,_277730]]],[[_277634,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_277652,_277634,_277724]]]],_277730,[return,_277730]]]],['_ret'=_277730,'_space'=_277724,'_atom'=_277652,'_type'=_277634],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(954,36),line_char(962,9))). -user:metta_file_buffer(26,347001132,indexed(metta_other,[switch,[_278542,_278564],[[[_278542,'Variable'],[return,_278652]],[[_278542,'Symbol'],[chain,[eval,['type-cast',_278652,_278542,_278800]],_278822,[return,_278822]]],[[_278542,'Grounded'],[chain,[eval,['type-cast',_278652,_278542,_278800]],_278822,[return,_278822]]],[[_278542,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_278652,_278542,_278800]]]],_278822,[return,_278822]]]]]),[switch,[_279338,_279344],[[[_279338,'Variable'],[return,_279386]],[[_279338,'Symbol'],[chain,[eval,['type-cast',_279386,_279338,_279458]],_279464,[return,_279464]]],[[_279338,'Grounded'],[chain,[eval,['type-cast',_279386,_279338,_279458]],_279464,[return,_279464]]],[[_279338,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_279386,_279338,_279458]]]],_279464,[return,_279464]]]]],['_ret'=_279464,'_space'=_279458,'_atom'=_279386,'_meta'=_279344,'_type'=_279338],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(954,14),line_char(962,10))). -user:metta_file_buffer(25,347001132,indexed(metta_other,[eval,[switch,[_280292,_280314],[[[_280292,'Variable'],[return,_280402]],[[_280292,'Symbol'],[chain,[eval,['type-cast',_280402,_280292,_280550]],_280572,[return,_280572]]],[[_280292,'Grounded'],[chain,[eval,['type-cast',_280402,_280292,_280550]],_280572,[return,_280572]]],[[_280292,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_280402,_280292,_280550]]]],_280572,[return,_280572]]]]]]),[eval,[switch,[_281100,_281106],[[[_281100,'Variable'],[return,_281148]],[[_281100,'Symbol'],[chain,[eval,['type-cast',_281148,_281100,_281220]],_281226,[return,_281226]]],[[_281100,'Grounded'],[chain,[eval,['type-cast',_281148,_281100,_281220]],_281226,[return,_281226]]],[[_281100,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_281148,_281100,_281220]]]],_281226,[return,_281226]]]]]],['_ret'=_281226,'_space'=_281220,'_atom'=_281148,'_meta'=_281106,'_type'=_281100],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(954,8),line_char(962,11))). -user:metta_file_buffer(24,347001132,indexed(metta_other,['if-equal',_282048,_282070,[return,_282108],[eval,[switch,[_282048,_282070],[[[_282048,'Variable'],[return,_282108]],[[_282048,'Symbol'],[chain,[eval,['type-cast',_282108,_282048,_282416]],_282438,[return,_282438]]],[[_282048,'Grounded'],[chain,[eval,['type-cast',_282108,_282048,_282416]],_282438,[return,_282438]]],[[_282048,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_282108,_282048,_282416]]]],_282438,[return,_282438]]]]]]]),['if-equal',_282948,_282954,[return,_282972],[eval,[switch,[_282948,_282954],[[[_282948,'Variable'],[return,_282972]],[[_282948,'Symbol'],[chain,[eval,['type-cast',_282972,_282948,_283128]],_283134,[return,_283134]]],[[_282948,'Grounded'],[chain,[eval,['type-cast',_282972,_282948,_283128]],_283134,[return,_283134]]],[[_282948,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_282972,_282948,_283128]]]],_283134,[return,_283134]]]]]]],['_ret'=_283134,'_space'=_283128,'_atom'=_282972,'_meta'=_282954,'_type'=_282948],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(952,12),line_char(962,12))). -user:metta_file_buffer(23,347001132,indexed(metta_other,[eval,['if-equal',_283954,_283976,[return,_284014],[eval,[switch,[_283954,_283976],[[[_283954,'Variable'],[return,_284014]],[[_283954,'Symbol'],[chain,[eval,['type-cast',_284014,_283954,_284322]],_284344,[return,_284344]]],[[_283954,'Grounded'],[chain,[eval,['type-cast',_284014,_283954,_284322]],_284344,[return,_284344]]],[[_283954,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_284014,_283954,_284322]]]],_284344,[return,_284344]]]]]]]]),[eval,['if-equal',_284866,_284872,[return,_284890],[eval,[switch,[_284866,_284872],[[[_284866,'Variable'],[return,_284890]],[[_284866,'Symbol'],[chain,[eval,['type-cast',_284890,_284866,_285046]],_285052,[return,_285052]]],[[_284866,'Grounded'],[chain,[eval,['type-cast',_284890,_284866,_285046]],_285052,[return,_285052]]],[[_284866,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_284890,_284866,_285046]]]],_285052,[return,_285052]]]]]]]],['_ret'=_285052,'_space'=_285046,'_atom'=_284890,'_meta'=_284872,'_type'=_284866],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(952,6),line_char(962,13))). -user:metta_file_buffer(22,347001132,indexed(metta_other,['if-equal',_285874,'Atom',[return,_285920],[eval,['if-equal',_285874,_285992,[return,_285920],[eval,[switch,[_285874,_285992],[[[_285874,'Variable'],[return,_285920]],[[_285874,'Symbol'],[chain,[eval,['type-cast',_285920,_285874,_286334]],_286356,[return,_286356]]],[[_285874,'Grounded'],[chain,[eval,['type-cast',_285920,_285874,_286334]],_286356,[return,_286356]]],[[_285874,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_285920,_285874,_286334]]]],_286356,[return,_286356]]]]]]]]]),['if-equal',_286866,'Atom',[return,_286890],[eval,['if-equal',_286866,_286926,[return,_286890],[eval,[switch,[_286866,_286926],[[[_286866,'Variable'],[return,_286890]],[[_286866,'Symbol'],[chain,[eval,['type-cast',_286890,_286866,_287100]],_287106,[return,_287106]]],[[_286866,'Grounded'],[chain,[eval,['type-cast',_286890,_286866,_287100]],_287106,[return,_287106]]],[[_286866,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_286890,_286866,_287100]]]],_287106,[return,_287106]]]]]]]]],['_ret'=_287106,'_space'=_287100,'_meta'=_286926,'_atom'=_286890,'_type'=_286866],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(950,10),line_char(962,14))). -user:metta_file_buffer(21,347001132,indexed(metta_other,[eval,['if-equal',_287926,'Atom',[return,_287972],[eval,['if-equal',_287926,_288044,[return,_287972],[eval,[switch,[_287926,_288044],[[[_287926,'Variable'],[return,_287972]],[[_287926,'Symbol'],[chain,[eval,['type-cast',_287972,_287926,_288386]],_288408,[return,_288408]]],[[_287926,'Grounded'],[chain,[eval,['type-cast',_287972,_287926,_288386]],_288408,[return,_288408]]],[[_287926,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_287972,_287926,_288386]]]],_288408,[return,_288408]]]]]]]]]]),[eval,['if-equal',_288930,'Atom',[return,_288954],[eval,['if-equal',_288930,_288990,[return,_288954],[eval,[switch,[_288930,_288990],[[[_288930,'Variable'],[return,_288954]],[[_288930,'Symbol'],[chain,[eval,['type-cast',_288954,_288930,_289164]],_289170,[return,_289170]]],[[_288930,'Grounded'],[chain,[eval,['type-cast',_288954,_288930,_289164]],_289170,[return,_289170]]],[[_288930,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_288954,_288930,_289164]]]],_289170,[return,_289170]]]]]]]]]],['_ret'=_289170,'_space'=_289164,'_meta'=_288990,'_atom'=_288954,'_type'=_288930],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(950,4),line_char(962,15))). -user:metta_file_buffer(20,347001132,indexed(metta_other,[chain,[eval,['get-metatype',_290018]],_290040,[eval,['if-equal',_290094,'Atom',[return,_290018],[eval,['if-equal',_290094,_290040,[return,_290018],[eval,[switch,[_290094,_290040],[[[_290094,'Variable'],[return,_290018]],[[_290094,'Symbol'],[chain,[eval,['type-cast',_290018,_290094,_290546]],_290568,[return,_290568]]],[[_290094,'Grounded'],[chain,[eval,['type-cast',_290018,_290094,_290546]],_290568,[return,_290568]]],[[_290094,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_290018,_290094,_290546]]]],_290568,[return,_290568]]]]]]]]]]]),[chain,[eval,['get-metatype',_291102]],_291108,[eval,['if-equal',_291138,'Atom',[return,_291102],[eval,['if-equal',_291138,_291108,[return,_291102],[eval,[switch,[_291138,_291108],[[[_291138,'Variable'],[return,_291102]],[[_291138,'Symbol'],[chain,[eval,['type-cast',_291102,_291138,_291372]],_291378,[return,_291378]]],[[_291138,'Grounded'],[chain,[eval,['type-cast',_291102,_291138,_291372]],_291378,[return,_291378]]],[[_291138,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_291102,_291138,_291372]]]],_291378,[return,_291378]]]]]]]]]]],['_ret'=_291378,'_space'=_291372,'_type'=_291138,'_meta'=_291108,'_atom'=_291102],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(949,12),line_char(962,16))). -user:metta_file_buffer(19,347001132,indexed(metta_other,[function,[chain,[eval,['get-metatype',_292230]],_292252,[eval,['if-equal',_292306,'Atom',[return,_292230],[eval,['if-equal',_292306,_292252,[return,_292230],[eval,[switch,[_292306,_292252],[[[_292306,'Variable'],[return,_292230]],[[_292306,'Symbol'],[chain,[eval,['type-cast',_292230,_292306,_292758]],_292780,[return,_292780]]],[[_292306,'Grounded'],[chain,[eval,['type-cast',_292230,_292306,_292758]],_292780,[return,_292780]]],[[_292306,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_292230,_292306,_292758]]]],_292780,[return,_292780]]]]]]]]]]]]),[function,[chain,[eval,['get-metatype',_293326]],_293332,[eval,['if-equal',_293362,'Atom',[return,_293326],[eval,['if-equal',_293362,_293332,[return,_293326],[eval,[switch,[_293362,_293332],[[[_293362,'Variable'],[return,_293326]],[[_293362,'Symbol'],[chain,[eval,['type-cast',_293326,_293362,_293596]],_293602,[return,_293602]]],[[_293362,'Grounded'],[chain,[eval,['type-cast',_293326,_293362,_293596]],_293602,[return,_293602]]],[[_293362,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_293326,_293362,_293596]]]],_293602,[return,_293602]]]]]]]]]]]],['_ret'=_293602,'_space'=_293596,'_type'=_293362,'_meta'=_293332,'_atom'=_293326],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(949,2),line_char(962,17))). -user:metta_file_buffer(18,347001132,indexed(metta_defun,[interpret,_294428,_294450,_294472]),[=,[interpret,_295618,_295624,_295630],[function,[chain,[eval,['get-metatype',_295618]],_295690,[eval,['if-equal',_295624,'Atom',[return,_295618],[eval,['if-equal',_295624,_295690,[return,_295618],[eval,[switch,[_295624,_295690],[[[_295624,'Variable'],[return,_295618]],[[_295624,'Symbol'],[chain,[eval,['type-cast',_295618,_295624,_295630]],_295960,[return,_295960]]],[[_295624,'Grounded'],[chain,[eval,['type-cast',_295618,_295624,_295630]],_295960,[return,_295960]]],[[_295624,'Expression'],[chain,[eval,['check-alternatives',[eval,['interpret-expression',_295618,_295624,_295630]]]],_295960,[return,_295960]]]]]]]]]]]]],['_ret'=_295960,'_meta'=_295690,'_space'=_295630,'_type'=_295624,'_atom'=_295618],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(948,0),line_char(962,18))). -user:metta_file_buffer(19,348001133,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(964,1),line_char(964,3))). -user:metta_file_buffer(19,348001133,constant,'interpret-expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(964,4),line_char(964,24))). -user:metta_file_buffer(19,348001133,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(964,25),line_char(964,43))). -user:metta_file_buffer(18,348001133,metta_other,[iz,'interpret-expression','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(964,0),line_char(964,44))). -user:metta_file_buffer(19,349001134,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(965,1),line_char(965,2))). -user:metta_file_buffer(20,349001135,constant,'interpret-expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(965,4),line_char(965,24))). -user:metta_file_buffer(20,349001135,variable,_190264,['_atom'=_190264],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(965,25),line_char(965,30))). -user:metta_file_buffer(20,349001135,variable,_191548,['_type'=_191548],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(965,31),line_char(965,36))). -user:metta_file_buffer(20,349001135,variable,_192856,['_space'=_192856],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(965,37),line_char(965,43))). -user:metta_file_buffer(19,349001135,indexed(metta_other,['interpret-expression',_193702,_193724,_193746]),['interpret-expression',_193798,_193804,_193810],['_space'=_193810,'_type'=_193804,'_atom'=_193798],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(965,3),line_char(965,44))). -user:metta_file_buffer(20,349001136,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(966,3),line_char(966,11))). -user:metta_file_buffer(21,349001137,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(966,13),line_char(966,17))). -user:metta_file_buffer(22,349001138,constant,'if-decons',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(966,19),line_char(966,28))). -user:metta_file_buffer(22,349001138,variable,_197214,['_atom'=_197214],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(966,29),line_char(966,34))). -user:metta_file_buffer(22,349001138,variable,_198466,['_op'=_198466],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(966,35),line_char(966,38))). -user:metta_file_buffer(22,349001138,variable,_199750,['_args'=_199750],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(966,39),line_char(966,44))). -user:metta_file_buffer(23,349001139,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(967,5),line_char(967,10))). -user:metta_file_buffer(24,349001140,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(967,12),line_char(967,16))). -user:metta_file_buffer(25,349001141,constant,'get-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(967,18),line_char(967,26))). -user:metta_file_buffer(25,349001141,variable,_203374,['_op'=_203374],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(967,27),line_char(967,30))). -user:metta_file_buffer(25,349001141,variable,_204682,['_space'=_204682],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(967,31),line_char(967,37))). -user:metta_file_buffer(24,349001141,indexed(metta_other,['get-type',_205522,_205544]),['get-type',_205596,_205602],['_space'=_205602,'_op'=_205596],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(967,17),line_char(967,38))). -user:metta_file_buffer(23,349001141,indexed(metta_other,[eval,['get-type',_206152,_206174]]),[eval,['get-type',_206238,_206244]],['_space'=_206244,'_op'=_206238],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(967,11),line_char(967,39))). -user:metta_file_buffer(23,349001141,variable,_207298,['_op_type'=_207298],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(967,40),line_char(967,48))). -user:metta_file_buffer(24,349001142,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(968,7),line_char(968,12))). -user:metta_file_buffer(25,349001143,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(968,14),line_char(968,18))). -user:metta_file_buffer(26,349001144,constant,'is-function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(968,20),line_char(968,31))). -user:metta_file_buffer(26,349001144,variable,_211066,['_op_type'=_211066],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(968,32),line_char(968,40))). -user:metta_file_buffer(25,349001144,indexed(metta_other,['is-function',_211900]),['is-function',_211952],['_op_type'=_211952],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(968,19),line_char(968,41))). -user:metta_file_buffer(24,349001144,indexed(metta_other,[eval,['is-function',_212490]]),[eval,['is-function',_212554]],['_op_type'=_212554],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(968,13),line_char(968,42))). -user:metta_file_buffer(24,349001144,variable,_213596,['_is_func'=_213596],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(968,43),line_char(968,51))). -user:metta_file_buffer(25,349001145,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(969,9),line_char(969,17))). -user:metta_file_buffer(25,349001145,variable,_215732,['_is_func'=_215732],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(969,18),line_char(969,26))). -user:metta_file_buffer(25,349001145,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(969,27),line_char(969,31))). -user:metta_file_buffer(26,349001146,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(970,11),line_char(970,16))). -user:metta_file_buffer(27,349001147,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(970,18),line_char(970,22))). -user:metta_file_buffer(28,349001148,constant,'interpret-func',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(970,24),line_char(970,38))). -user:metta_file_buffer(28,349001148,variable,_220048,['_atom'=_220048],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(970,39),line_char(970,44))). -user:metta_file_buffer(28,349001148,variable,_221402,['_op_type'=_221402],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(970,45),line_char(970,53))). -user:metta_file_buffer(28,349001148,variable,_222686,['_type'=_222686],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(970,54),line_char(970,59))). -user:metta_file_buffer(28,349001148,variable,_223994,['_space'=_223994],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(970,60),line_char(970,66))). -user:metta_file_buffer(27,349001148,indexed(metta_other,['interpret-func',_224846,_224868,_224890,_224912]),['interpret-func',_224964,_224970,_224976,_224982],['_space'=_224982,'_type'=_224976,'_op_type'=_224970,'_atom'=_224964],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(970,23),line_char(970,67))). -user:metta_file_buffer(26,349001148,indexed(metta_other,[eval,['interpret-func',_225556,_225578,_225600,_225622]]),[eval,['interpret-func',_225686,_225692,_225698,_225704]],['_space'=_225704,'_type'=_225698,'_op_type'=_225692,'_atom'=_225686],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(970,17),line_char(970,68))). -user:metta_file_buffer(26,349001148,variable,_226862,['_reduced_atom'=_226862],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(970,69),line_char(970,82))). -user:metta_file_buffer(27,349001149,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,13),line_char(971,18))). -user:metta_file_buffer(28,349001150,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,20),line_char(971,24))). -user:metta_file_buffer(29,349001151,constant,'metta-call',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,26),line_char(971,36))). -user:metta_file_buffer(29,349001151,variable,_230704,['_reduced_atom'=_230704],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,37),line_char(971,50))). -user:metta_file_buffer(29,349001151,variable,_231988,['_type'=_231988],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,51),line_char(971,56))). -user:metta_file_buffer(29,349001151,variable,_233296,['_space'=_233296],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,57),line_char(971,63))). -user:metta_file_buffer(28,349001151,indexed(metta_other,['metta-call',_234142,_234164,_234186]),['metta-call',_234238,_234244,_234250],['_space'=_234250,'_type'=_234244,'_reduced_atom'=_234238],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,25),line_char(971,64))). -user:metta_file_buffer(27,349001151,indexed(metta_other,[eval,['metta-call',_234812,_234834,_234856]]),[eval,['metta-call',_234920,_234926,_234932]],['_space'=_234932,'_type'=_234926,'_reduced_atom'=_234920],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,19),line_char(971,65))). -user:metta_file_buffer(27,349001151,variable,_235912,['_ret'=_235912],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,66),line_char(971,70))). -user:metta_file_buffer(28,349001152,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,72),line_char(971,78))). -user:metta_file_buffer(28,349001152,variable,_238002,['_ret'=_238002],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,79),line_char(971,83))). -user:metta_file_buffer(27,349001152,indexed(metta_other,[return,_238836]),[return,_238888],['_ret'=_238888],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,71),line_char(971,84))). -user:metta_file_buffer(26,349001152,indexed(metta_other,[chain,[eval,['metta-call',_239454,_239476,_239498]],_239520,[return,_239520]]),[chain,[eval,['metta-call',_239630,_239636,_239642]],_239648,[return,_239648]],['_ret'=_239648,'_space'=_239642,'_type'=_239636,'_reduced_atom'=_239630],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(971,12),line_char(971,85))). -user:metta_file_buffer(25,349001152,indexed(metta_other,[chain,[eval,['interpret-func',_240270,_240292,_240314,_240336]],_240358,[chain,[eval,['metta-call',_240358,_240314,_240336]],_240482,[return,_240482]]]),[chain,[eval,['interpret-func',_240592,_240598,_240604,_240610]],_240616,[chain,[eval,['metta-call',_240616,_240604,_240610]],_240676,[return,_240676]]],['_ret'=_240676,'_reduced_atom'=_240616,'_space'=_240610,'_type'=_240604,'_op_type'=_240598,'_atom'=_240592],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(970,10),line_char(971,87))). -user:metta_file_buffer(26,349001153,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(972,11),line_char(972,16))). -user:metta_file_buffer(27,349001154,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(972,18),line_char(972,22))). -user:metta_file_buffer(28,349001155,constant,'interpret-tuple',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(972,24),line_char(972,39))). -user:metta_file_buffer(28,349001155,variable,_244180,['_atom'=_244180],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(972,40),line_char(972,45))). -user:metta_file_buffer(28,349001155,variable,_245488,['_space'=_245488],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(972,46),line_char(972,52))). -user:metta_file_buffer(27,349001155,indexed(metta_other,['interpret-tuple',_246328,_246350]),['interpret-tuple',_246402,_246408],['_space'=_246408,'_atom'=_246402],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(972,23),line_char(972,53))). -user:metta_file_buffer(26,349001155,indexed(metta_other,[eval,['interpret-tuple',_246958,_246980]]),[eval,['interpret-tuple',_247044,_247050]],['_space'=_247050,'_atom'=_247044],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(972,17),line_char(972,54))). -user:metta_file_buffer(26,349001155,variable,_248184,['_reduced_atom'=_248184],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(972,55),line_char(972,68))). -user:metta_file_buffer(27,349001156,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,13),line_char(973,18))). -user:metta_file_buffer(28,349001157,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,20),line_char(973,24))). -user:metta_file_buffer(29,349001158,constant,'metta-call',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,26),line_char(973,36))). -user:metta_file_buffer(29,349001158,variable,_252026,['_reduced_atom'=_252026],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,37),line_char(973,50))). -user:metta_file_buffer(29,349001158,variable,_253310,['_type'=_253310],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,51),line_char(973,56))). -user:metta_file_buffer(29,349001158,variable,_254618,['_space'=_254618],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,57),line_char(973,63))). -user:metta_file_buffer(28,349001158,indexed(metta_other,['metta-call',_255464,_255486,_255508]),['metta-call',_255560,_255566,_255572],['_space'=_255572,'_type'=_255566,'_reduced_atom'=_255560],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,25),line_char(973,64))). -user:metta_file_buffer(27,349001158,indexed(metta_other,[eval,['metta-call',_256134,_256156,_256178]]),[eval,['metta-call',_256242,_256248,_256254]],['_space'=_256254,'_type'=_256248,'_reduced_atom'=_256242],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,19),line_char(973,65))). -user:metta_file_buffer(27,349001158,variable,_257234,['_ret'=_257234],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,66),line_char(973,70))). -user:metta_file_buffer(28,349001159,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,72),line_char(973,78))). -user:metta_file_buffer(28,349001159,variable,_259324,['_ret'=_259324],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,79),line_char(973,83))). -user:metta_file_buffer(27,349001159,indexed(metta_other,[return,_260158]),[return,_260210],['_ret'=_260210],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,71),line_char(973,84))). -user:metta_file_buffer(26,349001159,indexed(metta_other,[chain,[eval,['metta-call',_260776,_260798,_260820]],_260842,[return,_260842]]),[chain,[eval,['metta-call',_260952,_260958,_260964]],_260970,[return,_260970]],['_ret'=_260970,'_space'=_260964,'_type'=_260958,'_reduced_atom'=_260952],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(973,12),line_char(973,85))). -user:metta_file_buffer(25,349001159,indexed(metta_other,[chain,[eval,['interpret-tuple',_261592,_261614]],_261636,[chain,[eval,['metta-call',_261636,_261724,_261614]],_261764,[return,_261764]]]),[chain,[eval,['interpret-tuple',_261874,_261880]],_261886,[chain,[eval,['metta-call',_261886,_261934,_261880]],_261946,[return,_261946]]],['_ret'=_261946,'_type'=_261934,'_reduced_atom'=_261886,'_space'=_261880,'_atom'=_261874],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(972,10),line_char(973,87))). -user:metta_file_buffer(24,349001159,indexed(metta_other,['if-unify',_262552,'True',[chain,[eval,['interpret-func',_262630,_262652,_262674,_262696]],_262718,[chain,[eval,['metta-call',_262718,_262674,_262696]],_262842,[return,_262842]]],[chain,[eval,['interpret-tuple',_262630,_262696]],_262718,[chain,[eval,['metta-call',_262718,_262674,_262696]],_262842,[return,_262842]]]]),['if-unify',_263184,'True',[chain,[eval,['interpret-func',_263232,_263238,_263244,_263250]],_263256,[chain,[eval,['metta-call',_263256,_263244,_263250]],_263316,[return,_263316]]],[chain,[eval,['interpret-tuple',_263232,_263250]],_263256,[chain,[eval,['metta-call',_263256,_263244,_263250]],_263316,[return,_263316]]]],['_ret'=_263316,'_reduced_atom'=_263256,'_space'=_263250,'_type'=_263244,'_op_type'=_263238,'_atom'=_263232,'_is_func'=_263184],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(969,8),line_char(973,88))). -user:metta_file_buffer(23,349001159,indexed(metta_other,[chain,[eval,['is-function',_264104]],_264126,['if-unify',_264126,'True',[chain,[eval,['interpret-func',_264238,_264104,_264278,_264300]],_264322,[chain,[eval,['metta-call',_264322,_264278,_264300]],_264446,[return,_264446]]],[chain,[eval,['interpret-tuple',_264238,_264300]],_264322,[chain,[eval,['metta-call',_264322,_264278,_264300]],_264446,[return,_264446]]]]]),[chain,[eval,['is-function',_264812]],_264818,['if-unify',_264818,'True',[chain,[eval,['interpret-func',_264884,_264812,_264896,_264902]],_264908,[chain,[eval,['metta-call',_264908,_264896,_264902]],_264968,[return,_264968]]],[chain,[eval,['interpret-tuple',_264884,_264902]],_264908,[chain,[eval,['metta-call',_264908,_264896,_264902]],_264968,[return,_264968]]]]],['_ret'=_264968,'_reduced_atom'=_264908,'_space'=_264902,'_type'=_264896,'_atom'=_264884,'_is_func'=_264818,'_op_type'=_264812],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(968,6),line_char(973,89))). -user:metta_file_buffer(22,349001159,indexed(metta_other,[chain,[eval,['get-type',_265756,_265778]],_265800,[chain,[eval,['is-function',_265800]],_265888,['if-unify',_265888,'True',[chain,[eval,['interpret-func',_266000,_265800,_266040,_265778]],_266080,[chain,[eval,['metta-call',_266080,_266040,_265778]],_266204,[return,_266204]]],[chain,[eval,['interpret-tuple',_266000,_265778]],_266080,[chain,[eval,['metta-call',_266080,_266040,_265778]],_266204,[return,_266204]]]]]]),[chain,[eval,['get-type',_266570,_266576]],_266582,[chain,[eval,['is-function',_266582]],_266630,['if-unify',_266630,'True',[chain,[eval,['interpret-func',_266696,_266582,_266708,_266576]],_266720,[chain,[eval,['metta-call',_266720,_266708,_266576]],_266780,[return,_266780]]],[chain,[eval,['interpret-tuple',_266696,_266576]],_266720,[chain,[eval,['metta-call',_266720,_266708,_266576]],_266780,[return,_266780]]]]]],['_ret'=_266780,'_reduced_atom'=_266720,'_type'=_266708,'_atom'=_266696,'_is_func'=_266630,'_op_type'=_266582,'_space'=_266576,'_op'=_266570],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(967,4),line_char(973,90))). -user:metta_file_buffer(23,349001160,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,5),line_char(974,10))). -user:metta_file_buffer(24,349001161,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,12),line_char(974,16))). -user:metta_file_buffer(25,349001162,constant,'type-cast',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,18),line_char(974,27))). -user:metta_file_buffer(25,349001162,variable,_270368,['_atom'=_270368],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,28),line_char(974,33))). -user:metta_file_buffer(25,349001162,variable,_271652,['_type'=_271652],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,34),line_char(974,39))). -user:metta_file_buffer(25,349001162,variable,_272960,['_space'=_272960],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,40),line_char(974,46))). -user:metta_file_buffer(24,349001162,indexed(metta_other,['type-cast',_273806,_273828,_273850]),['type-cast',_273902,_273908,_273914],['_space'=_273914,'_type'=_273908,'_atom'=_273902],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,17),line_char(974,47))). -user:metta_file_buffer(23,349001162,indexed(metta_other,[eval,['type-cast',_274476,_274498,_274520]]),[eval,['type-cast',_274584,_274590,_274596]],['_space'=_274596,'_type'=_274590,'_atom'=_274584],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,11),line_char(974,48))). -user:metta_file_buffer(23,349001162,variable,_275576,['_ret'=_275576],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,49),line_char(974,53))). -user:metta_file_buffer(24,349001163,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,55),line_char(974,61))). -user:metta_file_buffer(24,349001163,variable,_277666,['_ret'=_277666],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,62),line_char(974,66))). -user:metta_file_buffer(23,349001163,indexed(metta_other,[return,_278500]),[return,_278552],['_ret'=_278552],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,54),line_char(974,67))). -user:metta_file_buffer(22,349001163,indexed(metta_other,[chain,[eval,['type-cast',_279118,_279140,_279162]],_279184,[return,_279184]]),[chain,[eval,['type-cast',_279294,_279300,_279306]],_279312,[return,_279312]],['_ret'=_279312,'_space'=_279306,'_type'=_279300,'_atom'=_279294],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(974,4),line_char(974,68))). -user:metta_file_buffer(21,349001163,indexed(metta_other,['if-decons',_279914,_279936,_279958,[chain,[eval,['get-type',_279936,_280046]],_280068,[chain,[eval,['is-function',_280068]],_280156,['if-unify',_280156,'True',[chain,[eval,['interpret-func',_279914,_280068,_280304,_280046]],_280344,[chain,[eval,['metta-call',_280344,_280304,_280046]],_280468,[return,_280468]]],[chain,[eval,['interpret-tuple',_279914,_280046]],_280344,[chain,[eval,['metta-call',_280344,_280304,_280046]],_280468,[return,_280468]]]]]],[chain,[eval,['type-cast',_279914,_280304,_280046]],_280468,[return,_280468]]]),['if-decons',_280964,_280970,_280976,[chain,[eval,['get-type',_280970,_281024]],_281030,[chain,[eval,['is-function',_281030]],_281078,['if-unify',_281078,'True',[chain,[eval,['interpret-func',_280964,_281030,_281156,_281024]],_281168,[chain,[eval,['metta-call',_281168,_281156,_281024]],_281228,[return,_281228]]],[chain,[eval,['interpret-tuple',_280964,_281024]],_281168,[chain,[eval,['metta-call',_281168,_281156,_281024]],_281228,[return,_281228]]]]]],[chain,[eval,['type-cast',_280964,_281156,_281024]],_281228,[return,_281228]]],['_ret'=_281228,'_reduced_atom'=_281168,'_type'=_281156,'_is_func'=_281078,'_op_type'=_281030,'_space'=_281024,'_args'=_280976,'_op'=_280970,'_atom'=_280964],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(966,18),line_char(974,70))). -user:metta_file_buffer(20,349001163,indexed(metta_other,[eval,['if-decons',_282090,_282112,_282134,[chain,[eval,['get-type',_282112,_282222]],_282244,[chain,[eval,['is-function',_282244]],_282332,['if-unify',_282332,'True',[chain,[eval,['interpret-func',_282090,_282244,_282480,_282222]],_282520,[chain,[eval,['metta-call',_282520,_282480,_282222]],_282644,[return,_282644]]],[chain,[eval,['interpret-tuple',_282090,_282222]],_282520,[chain,[eval,['metta-call',_282520,_282480,_282222]],_282644,[return,_282644]]]]]],[chain,[eval,['type-cast',_282090,_282480,_282222]],_282644,[return,_282644]]]]),[eval,['if-decons',_283152,_283158,_283164,[chain,[eval,['get-type',_283158,_283212]],_283218,[chain,[eval,['is-function',_283218]],_283266,['if-unify',_283266,'True',[chain,[eval,['interpret-func',_283152,_283218,_283344,_283212]],_283356,[chain,[eval,['metta-call',_283356,_283344,_283212]],_283416,[return,_283416]]],[chain,[eval,['interpret-tuple',_283152,_283212]],_283356,[chain,[eval,['metta-call',_283356,_283344,_283212]],_283416,[return,_283416]]]]]],[chain,[eval,['type-cast',_283152,_283344,_283212]],_283416,[return,_283416]]]],['_ret'=_283416,'_reduced_atom'=_283356,'_type'=_283344,'_is_func'=_283266,'_op_type'=_283218,'_space'=_283212,'_args'=_283164,'_op'=_283158,'_atom'=_283152],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(966,12),line_char(974,71))). -user:metta_file_buffer(19,349001163,indexed(metta_other,[function,[eval,['if-decons',_284294,_284316,_284338,[chain,[eval,['get-type',_284316,_284426]],_284448,[chain,[eval,['is-function',_284448]],_284536,['if-unify',_284536,'True',[chain,[eval,['interpret-func',_284294,_284448,_284684,_284426]],_284724,[chain,[eval,['metta-call',_284724,_284684,_284426]],_284848,[return,_284848]]],[chain,[eval,['interpret-tuple',_284294,_284426]],_284724,[chain,[eval,['metta-call',_284724,_284684,_284426]],_284848,[return,_284848]]]]]],[chain,[eval,['type-cast',_284294,_284684,_284426]],_284848,[return,_284848]]]]]),[function,[eval,['if-decons',_285368,_285374,_285380,[chain,[eval,['get-type',_285374,_285428]],_285434,[chain,[eval,['is-function',_285434]],_285482,['if-unify',_285482,'True',[chain,[eval,['interpret-func',_285368,_285434,_285560,_285428]],_285572,[chain,[eval,['metta-call',_285572,_285560,_285428]],_285632,[return,_285632]]],[chain,[eval,['interpret-tuple',_285368,_285428]],_285572,[chain,[eval,['metta-call',_285572,_285560,_285428]],_285632,[return,_285632]]]]]],[chain,[eval,['type-cast',_285368,_285560,_285428]],_285632,[return,_285632]]]]],['_ret'=_285632,'_reduced_atom'=_285572,'_type'=_285560,'_is_func'=_285482,'_op_type'=_285434,'_space'=_285428,'_args'=_285380,'_op'=_285374,'_atom'=_285368],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(966,2),line_char(974,72))). -user:metta_file_buffer(18,349001163,indexed(metta_defun,['interpret-expression',_286500,_286522,_286544]),[=,['interpret-expression',_287664,_287670,_287676],[function,[eval,['if-decons',_287664,_287724,_287730,[chain,[eval,['get-type',_287724,_287676]],_287784,[chain,[eval,['is-function',_287784]],_287832,['if-unify',_287832,'True',[chain,[eval,['interpret-func',_287664,_287784,_287670,_287676]],_287922,[chain,[eval,['metta-call',_287922,_287670,_287676]],_287982,[return,_287982]]],[chain,[eval,['interpret-tuple',_287664,_287676]],_287922,[chain,[eval,['metta-call',_287922,_287670,_287676]],_287982,[return,_287982]]]]]],[chain,[eval,['type-cast',_287664,_287670,_287676]],_287982,[return,_287982]]]]]],['_ret'=_287982,'_reduced_atom'=_287922,'_is_func'=_287832,'_op_type'=_287784,'_args'=_287730,'_op'=_287724,'_space'=_287676,'_type'=_287670,'_atom'=_287664],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(965,0),line_char(974,73))). -user:metta_file_buffer(19,350001164,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(976,1),line_char(976,3))). -user:metta_file_buffer(19,350001164,constant,'interpret-func',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(976,4),line_char(976,18))). -user:metta_file_buffer(19,350001164,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(976,19),line_char(976,37))). -user:metta_file_buffer(18,350001164,metta_other,[iz,'interpret-func','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(976,0),line_char(976,38))). -user:metta_file_buffer(19,351001165,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(977,1),line_char(977,2))). -user:metta_file_buffer(20,351001166,constant,'interpret-func',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(977,4),line_char(977,18))). -user:metta_file_buffer(20,351001166,variable,_190204,['_expr'=_190204],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(977,19),line_char(977,24))). -user:metta_file_buffer(20,351001166,variable,_191488,['_type'=_191488],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(977,25),line_char(977,30))). -user:metta_file_buffer(20,351001166,variable,_192858,['_ret_type'=_192858],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(977,31),line_char(977,40))). -user:metta_file_buffer(20,351001166,variable,_194166,['_space'=_194166],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(977,41),line_char(977,47))). -user:metta_file_buffer(19,351001166,indexed(metta_other,['interpret-func',_195018,_195040,_195062,_195084]),['interpret-func',_195136,_195142,_195148,_195154],['_space'=_195154,'_ret_type'=_195148,'_type'=_195142,'_expr'=_195136],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(977,3),line_char(977,48))). -user:metta_file_buffer(20,351001167,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(978,3),line_char(978,11))). -user:metta_file_buffer(21,351001168,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(978,13),line_char(978,17))). -user:metta_file_buffer(22,351001169,constant,'if-decons',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(978,19),line_char(978,28))). -user:metta_file_buffer(22,351001169,variable,_198570,['_expr'=_198570],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(978,29),line_char(978,34))). -user:metta_file_buffer(22,351001169,variable,_199822,['_op'=_199822],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(978,35),line_char(978,38))). -user:metta_file_buffer(22,351001169,variable,_201106,['_args'=_201106],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(978,39),line_char(978,44))). -user:metta_file_buffer(23,351001170,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(979,5),line_char(979,10))). -user:metta_file_buffer(24,351001171,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(979,12),line_char(979,16))). -user:metta_file_buffer(25,351001172,constant,interpret,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(979,18),line_char(979,27))). -user:metta_file_buffer(25,351001172,variable,_204808,['_op'=_204808],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(979,28),line_char(979,31))). -user:metta_file_buffer(25,351001172,variable,_206092,['_type'=_206092],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(979,32),line_char(979,37))). -user:metta_file_buffer(25,351001172,variable,_207400,['_space'=_207400],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(979,38),line_char(979,44))). -user:metta_file_buffer(24,351001172,indexed(metta_other,[interpret,_208246,_208268,_208290]),[interpret,_208342,_208348,_208354],['_space'=_208354,'_type'=_208348,'_op'=_208342],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(979,17),line_char(979,45))). -user:metta_file_buffer(23,351001172,indexed(metta_other,[eval,[interpret,_208916,_208938,_208960]]),[eval,[interpret,_209024,_209030,_209036]],['_space'=_209036,'_type'=_209030,'_op'=_209024],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(979,11),line_char(979,46))). -user:metta_file_buffer(23,351001172,variable,_210150,['_reduced_op'=_210150],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(979,47),line_char(979,58))). -user:metta_file_buffer(24,351001173,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(980,7),line_char(980,11))). -user:metta_file_buffer(25,351001174,constant,'return-on-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(980,13),line_char(980,28))). -user:metta_file_buffer(25,351001174,variable,_213194,['_reduced_op'=_213194],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(980,29),line_char(980,40))). -user:metta_file_buffer(26,351001175,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(981,9),line_char(981,13))). -user:metta_file_buffer(27,351001176,constant,'if-decons',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(981,15),line_char(981,24))). -user:metta_file_buffer(27,351001176,variable,_216064,['_type'=_216064],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(981,25),line_char(981,30))). -user:metta_file_buffer(27,351001176,variable,_217364,['_arrow'=_217364],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(981,31),line_char(981,37))). -user:metta_file_buffer(27,351001176,variable,_218750,['_arg_types'=_218750],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(981,38),line_char(981,48))). -user:metta_file_buffer(28,351001177,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(982,11),line_char(982,16))). -user:metta_file_buffer(29,351001178,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(982,18),line_char(982,22))). -user:metta_file_buffer(30,351001179,constant,'interpret-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(982,24),line_char(982,38))). -user:metta_file_buffer(30,351001179,variable,_222478,['_expr'=_222478],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(982,39),line_char(982,44))). -user:metta_file_buffer(30,351001179,variable,_223762,['_args'=_223762],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(982,45),line_char(982,50))). -user:metta_file_buffer(30,351001179,variable,_225148,['_arg_types'=_225148],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(982,51),line_char(982,61))). -user:metta_file_buffer(30,351001179,variable,_226518,['_ret_type'=_226518],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(982,62),line_char(982,71))). -user:metta_file_buffer(30,351001179,variable,_227826,['_space'=_227826],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(982,72),line_char(982,78))). -user:metta_file_buffer(29,351001179,indexed(metta_other,['interpret-args',_228684,_228706,_228728,_228750,_228772]),['interpret-args',_228824,_228830,_228836,_228842,_228848],['_space'=_228848,'_ret_type'=_228842,'_arg_types'=_228836,'_args'=_228830,'_expr'=_228824],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(982,23),line_char(982,79))). -user:metta_file_buffer(28,351001179,indexed(metta_other,[eval,['interpret-args',_229434,_229456,_229478,_229500,_229522]]),[eval,['interpret-args',_229586,_229592,_229598,_229604,_229610]],['_space'=_229610,'_ret_type'=_229604,'_arg_types'=_229598,'_args'=_229592,'_expr'=_229586],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(982,17),line_char(982,80))). -user:metta_file_buffer(28,351001179,variable,_230780,['_reduced_args'=_230780],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(982,81),line_char(982,94))). -user:metta_file_buffer(29,351001180,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(983,13),line_char(983,17))). -user:metta_file_buffer(30,351001181,constant,'return-on-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(983,19),line_char(983,34))). -user:metta_file_buffer(30,351001181,variable,_233868,['_reduced_args'=_233868],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(983,35),line_char(983,48))). -user:metta_file_buffer(31,351001182,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(984,15),line_char(984,20))). -user:metta_file_buffer(32,351001183,constant,'cons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(984,22),line_char(984,31))). -user:metta_file_buffer(32,351001183,variable,_236878,['_reduced_op'=_236878],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(984,32),line_char(984,43))). -user:metta_file_buffer(32,351001183,variable,_238320,['_reduced_args'=_238320],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(984,44),line_char(984,57))). -user:metta_file_buffer(31,351001183,indexed(metta_other,['cons-atom',_239160,_239182]),['cons-atom',_239234,_239240],['_reduced_args'=_239240,'_reduced_op'=_239234],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(984,21),line_char(984,58))). -user:metta_file_buffer(31,351001183,variable,_240176,['_r'=_240176],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(984,59),line_char(984,61))). -user:metta_file_buffer(32,351001184,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(984,63),line_char(984,69))). -user:metta_file_buffer(32,351001184,variable,_242234,['_r'=_242234],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(984,70),line_char(984,72))). -user:metta_file_buffer(31,351001184,indexed(metta_other,[return,_243068]),[return,_243120],['_r'=_243120],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(984,62),line_char(984,73))). -user:metta_file_buffer(30,351001184,indexed(metta_other,[chain,['cons-atom',_243670,_243692],_243714,[return,_243714]]),[chain,['cons-atom',_243812,_243818],_243824,[return,_243824]],['_r'=_243824,'_reduced_args'=_243818,'_reduced_op'=_243812],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(984,14),line_char(984,74))). -user:metta_file_buffer(29,351001184,indexed(metta_other,['return-on-error',_244394,[chain,['cons-atom',_244448,_244394],_244488,[return,_244488]]]),['return-on-error',_244574,[chain,['cons-atom',_244604,_244574],_244616,[return,_244616]]],['_r'=_244616,'_reduced_op'=_244604,'_reduced_args'=_244574],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(983,18),line_char(984,75))). -user:metta_file_buffer(28,351001184,indexed(metta_other,[eval,['return-on-error',_245196,[chain,['cons-atom',_245250,_245196],_245290,[return,_245290]]]]),[eval,['return-on-error',_245388,[chain,['cons-atom',_245418,_245388],_245430,[return,_245430]]]],['_r'=_245430,'_reduced_op'=_245418,'_reduced_args'=_245388],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(983,12),line_char(984,76))). -user:metta_file_buffer(27,351001184,indexed(metta_other,[chain,[eval,['interpret-args',_246038,_246060,_246082,_246104,_246126]],_246148,[eval,['return-on-error',_246148,[chain,['cons-atom',_246252,_246148],_246292,[return,_246292]]]]]),[chain,[eval,['interpret-args',_246402,_246408,_246414,_246420,_246426]],_246432,[eval,['return-on-error',_246432,[chain,['cons-atom',_246492,_246432],_246504,[return,_246504]]]]],['_r'=_246504,'_reduced_op'=_246492,'_reduced_args'=_246432,'_space'=_246426,'_ret_type'=_246420,'_arg_types'=_246414,'_args'=_246408,'_expr'=_246402],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(982,10),line_char(984,77))). -user:metta_file_buffer(28,351001185,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(985,11),line_char(985,17))). -user:metta_file_buffer(29,351001186,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(985,19),line_char(985,24))). -user:metta_file_buffer(29,351001186,variable,_249148,['_type'=_249148],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(985,25),line_char(985,30))). -user:metta_file_buffer(29,351001186,string,"Function type expected",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(985,31),line_char(985,55))). -user:metta_file_buffer(28,351001186,indexed(metta_other,['Error',_250768,"Function type expected"]),['Error',_250828,"Function type expected"],['_type'=_250828],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(985,18),line_char(985,56))). -user:metta_file_buffer(27,351001186,indexed(metta_other,[return,['Error',_251366,"Function type expected"]]),[return,['Error',_251438,"Function type expected"]],['_type'=_251438],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(985,10),line_char(985,57))). -user:metta_file_buffer(26,351001186,indexed(metta_other,['if-decons',_251986,_252008,_252030,[chain,[eval,['interpret-args',_252100,_252122,_252030,_252162,_252184]],_252206,[eval,['return-on-error',_252206,[chain,['cons-atom',_252310,_252206],_252350,[return,_252350]]]]],[return,['Error',_251986,"Function type expected"]]]),['if-decons',_252494,_252500,_252506,[chain,[eval,['interpret-args',_252548,_252554,_252506,_252566,_252572]],_252578,[eval,['return-on-error',_252578,[chain,['cons-atom',_252638,_252578],_252650,[return,_252650]]]]],[return,['Error',_252494,"Function type expected"]]],['_r'=_252650,'_reduced_op'=_252638,'_reduced_args'=_252578,'_space'=_252572,'_ret_type'=_252566,'_args'=_252554,'_expr'=_252548,'_arg_types'=_252506,'_arrow'=_252500,'_type'=_252494],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(981,14),line_char(985,59))). -user:metta_file_buffer(25,351001186,indexed(metta_other,[eval,['if-decons',_253344,_253366,_253388,[chain,[eval,['interpret-args',_253458,_253480,_253388,_253520,_253542]],_253564,[eval,['return-on-error',_253564,[chain,['cons-atom',_253668,_253564],_253708,[return,_253708]]]]],[return,['Error',_253344,"Function type expected"]]]]),[eval,['if-decons',_253864,_253870,_253876,[chain,[eval,['interpret-args',_253918,_253924,_253876,_253936,_253942]],_253948,[eval,['return-on-error',_253948,[chain,['cons-atom',_254008,_253948],_254020,[return,_254020]]]]],[return,['Error',_253864,"Function type expected"]]]],['_r'=_254020,'_reduced_op'=_254008,'_reduced_args'=_253948,'_space'=_253942,'_ret_type'=_253936,'_args'=_253924,'_expr'=_253918,'_arg_types'=_253876,'_arrow'=_253870,'_type'=_253864],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(981,8),line_char(985,60))). -user:metta_file_buffer(24,351001186,indexed(metta_other,['return-on-error',_254704,[eval,['if-decons',_254758,_254780,_254802,[chain,[eval,['interpret-args',_254872,_254894,_254802,_254934,_254956]],_254978,[eval,['return-on-error',_254978,[chain,['cons-atom',_254704,_254978],_255118,[return,_255118]]]]],[return,['Error',_254758,"Function type expected"]]]]]),['return-on-error',_255262,[eval,['if-decons',_255292,_255298,_255304,[chain,[eval,['interpret-args',_255346,_255352,_255304,_255364,_255370]],_255376,[eval,['return-on-error',_255376,[chain,['cons-atom',_255262,_255376],_255448,[return,_255448]]]]],[return,['Error',_255292,"Function type expected"]]]]],['_r'=_255448,'_reduced_args'=_255376,'_space'=_255370,'_ret_type'=_255364,'_args'=_255352,'_expr'=_255346,'_arg_types'=_255304,'_arrow'=_255298,'_type'=_255292,'_reduced_op'=_255262],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(980,12),line_char(985,61))). -user:metta_file_buffer(23,351001186,indexed(metta_other,[eval,['return-on-error',_256142,[eval,['if-decons',_256196,_256218,_256240,[chain,[eval,['interpret-args',_256310,_256332,_256240,_256372,_256394]],_256416,[eval,['return-on-error',_256416,[chain,['cons-atom',_256142,_256416],_256556,[return,_256556]]]]],[return,['Error',_256196,"Function type expected"]]]]]]),[eval,['return-on-error',_256712,[eval,['if-decons',_256742,_256748,_256754,[chain,[eval,['interpret-args',_256796,_256802,_256754,_256814,_256820]],_256826,[eval,['return-on-error',_256826,[chain,['cons-atom',_256712,_256826],_256898,[return,_256898]]]]],[return,['Error',_256742,"Function type expected"]]]]]],['_r'=_256898,'_reduced_args'=_256826,'_space'=_256820,'_ret_type'=_256814,'_args'=_256802,'_expr'=_256796,'_arg_types'=_256754,'_arrow'=_256748,'_type'=_256742,'_reduced_op'=_256712],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(980,6),line_char(985,62))). -user:metta_file_buffer(22,351001186,indexed(metta_other,[chain,[eval,[interpret,_257620,_257642,_257664]],_257686,[eval,['return-on-error',_257686,[eval,['if-decons',_257642,_257808,_257830,[chain,[eval,['interpret-args',_257900,_257922,_257830,_257962,_257664]],_258002,[eval,['return-on-error',_258002,[chain,['cons-atom',_257686,_258002],_258142,[return,_258142]]]]],[return,['Error',_257642,"Function type expected"]]]]]]]),[chain,[eval,[interpret,_258310,_258316,_258322]],_258328,[eval,['return-on-error',_258328,[eval,['if-decons',_258316,_258394,_258400,[chain,[eval,['interpret-args',_258442,_258448,_258400,_258460,_258322]],_258472,[eval,['return-on-error',_258472,[chain,['cons-atom',_258328,_258472],_258544,[return,_258544]]]]],[return,['Error',_258316,"Function type expected"]]]]]]],['_r'=_258544,'_reduced_args'=_258472,'_ret_type'=_258460,'_args'=_258448,'_expr'=_258442,'_arg_types'=_258400,'_arrow'=_258394,'_reduced_op'=_258328,'_space'=_258322,'_type'=_258316,'_op'=_258310],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(979,4),line_char(985,63))). -user:metta_file_buffer(23,351001187,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(986,5),line_char(986,11))). -user:metta_file_buffer(24,351001188,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(986,13),line_char(986,18))). -user:metta_file_buffer(24,351001188,variable,_261242,['_expr'=_261242],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(986,19),line_char(986,24))). -user:metta_file_buffer(24,351001188,string,"Non-empty expression atom is expected",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(986,25),line_char(986,64))). -user:metta_file_buffer(23,351001188,indexed(metta_other,['Error',_263016,"Non-empty expression atom is expected"]),['Error',_263076,"Non-empty expression atom is expected"],['_expr'=_263076],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(986,12),line_char(986,65))). -user:metta_file_buffer(22,351001188,indexed(metta_other,[return,['Error',_263614,"Non-empty expression atom is expected"]]),[return,['Error',_263686,"Non-empty expression atom is expected"]],['_expr'=_263686],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(986,4),line_char(986,66))). -user:metta_file_buffer(21,351001188,indexed(metta_other,['if-decons',_264234,_264256,_264278,[chain,[eval,[interpret,_264256,_264366,_264388]],_264410,[eval,['return-on-error',_264410,[eval,['if-decons',_264366,_264532,_264554,[chain,[eval,['interpret-args',_264234,_264278,_264554,_264678,_264388]],_264718,[eval,['return-on-error',_264718,[chain,['cons-atom',_264410,_264718],_264858,[return,_264858]]]]],[return,['Error',_264366,"Function type expected"]]]]]]],[return,['Error',_264234,"Non-empty expression atom is expected"]]]),['if-decons',_265060,_265066,_265072,[chain,[eval,[interpret,_265066,_265120,_265126]],_265132,[eval,['return-on-error',_265132,[eval,['if-decons',_265120,_265198,_265204,[chain,[eval,['interpret-args',_265060,_265072,_265204,_265264,_265126]],_265276,[eval,['return-on-error',_265276,[chain,['cons-atom',_265132,_265276],_265348,[return,_265348]]]]],[return,['Error',_265120,"Function type expected"]]]]]]],[return,['Error',_265060,"Non-empty expression atom is expected"]]],['_r'=_265348,'_reduced_args'=_265276,'_ret_type'=_265264,'_arg_types'=_265204,'_arrow'=_265198,'_reduced_op'=_265132,'_space'=_265126,'_type'=_265120,'_args'=_265072,'_op'=_265066,'_expr'=_265060],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(978,18),line_char(986,68))). -user:metta_file_buffer(20,351001188,indexed(metta_other,[eval,['if-decons',_266084,_266106,_266128,[chain,[eval,[interpret,_266106,_266216,_266238]],_266260,[eval,['return-on-error',_266260,[eval,['if-decons',_266216,_266382,_266404,[chain,[eval,['interpret-args',_266084,_266128,_266404,_266528,_266238]],_266568,[eval,['return-on-error',_266568,[chain,['cons-atom',_266260,_266568],_266708,[return,_266708]]]]],[return,['Error',_266216,"Function type expected"]]]]]]],[return,['Error',_266084,"Non-empty expression atom is expected"]]]]),[eval,['if-decons',_266922,_266928,_266934,[chain,[eval,[interpret,_266928,_266982,_266988]],_266994,[eval,['return-on-error',_266994,[eval,['if-decons',_266982,_267060,_267066,[chain,[eval,['interpret-args',_266922,_266934,_267066,_267126,_266988]],_267138,[eval,['return-on-error',_267138,[chain,['cons-atom',_266994,_267138],_267210,[return,_267210]]]]],[return,['Error',_266982,"Function type expected"]]]]]]],[return,['Error',_266922,"Non-empty expression atom is expected"]]]],['_r'=_267210,'_reduced_args'=_267138,'_ret_type'=_267126,'_arg_types'=_267066,'_arrow'=_267060,'_reduced_op'=_266994,'_space'=_266988,'_type'=_266982,'_args'=_266934,'_op'=_266928,'_expr'=_266922],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(978,12),line_char(986,69))). -user:metta_file_buffer(19,351001188,indexed(metta_other,[function,[eval,['if-decons',_267962,_267984,_268006,[chain,[eval,[interpret,_267984,_268094,_268116]],_268138,[eval,['return-on-error',_268138,[eval,['if-decons',_268094,_268260,_268282,[chain,[eval,['interpret-args',_267962,_268006,_268282,_268406,_268116]],_268446,[eval,['return-on-error',_268446,[chain,['cons-atom',_268138,_268446],_268586,[return,_268586]]]]],[return,['Error',_268094,"Function type expected"]]]]]]],[return,['Error',_267962,"Non-empty expression atom is expected"]]]]]),[function,[eval,['if-decons',_268812,_268818,_268824,[chain,[eval,[interpret,_268818,_268872,_268878]],_268884,[eval,['return-on-error',_268884,[eval,['if-decons',_268872,_268950,_268956,[chain,[eval,['interpret-args',_268812,_268824,_268956,_269016,_268878]],_269028,[eval,['return-on-error',_269028,[chain,['cons-atom',_268884,_269028],_269100,[return,_269100]]]]],[return,['Error',_268872,"Function type expected"]]]]]]],[return,['Error',_268812,"Non-empty expression atom is expected"]]]]],['_r'=_269100,'_reduced_args'=_269028,'_ret_type'=_269016,'_arg_types'=_268956,'_arrow'=_268950,'_reduced_op'=_268884,'_space'=_268878,'_type'=_268872,'_args'=_268824,'_op'=_268818,'_expr'=_268812],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(978,2),line_char(986,70))). -user:metta_file_buffer(18,351001188,indexed(metta_defun,['interpret-func',_269842,_269864,_269886,_269908]),[=,['interpret-func',_270800,_270806,_270812,_270818],[function,[eval,['if-decons',_270800,_270866,_270872,[chain,[eval,[interpret,_270866,_270806,_270818]],_270932,[eval,['return-on-error',_270932,[eval,['if-decons',_270806,_270998,_271004,[chain,[eval,['interpret-args',_270800,_270872,_271004,_270812,_270818]],_271076,[eval,['return-on-error',_271076,[chain,['cons-atom',_270932,_271076],_271148,[return,_271148]]]]],[return,['Error',_270806,"Function type expected"]]]]]]],[return,['Error',_270800,"Non-empty expression atom is expected"]]]]]],['_r'=_271148,'_reduced_args'=_271076,'_arg_types'=_271004,'_arrow'=_270998,'_reduced_op'=_270932,'_args'=_270872,'_op'=_270866,'_space'=_270818,'_ret_type'=_270812,'_type'=_270806,'_expr'=_270800],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(977,0),line_char(986,71))). -user:metta_file_buffer(19,352001189,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(988,1),line_char(988,3))). -user:metta_file_buffer(19,352001189,constant,'interpret-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(988,4),line_char(988,18))). -user:metta_file_buffer(19,352001189,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(988,19),line_char(988,37))). -user:metta_file_buffer(18,352001189,metta_other,[iz,'interpret-args','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(988,0),line_char(988,38))). -user:metta_file_buffer(19,353001190,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(989,1),line_char(989,2))). -user:metta_file_buffer(20,353001191,constant,'interpret-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(989,4),line_char(989,18))). -user:metta_file_buffer(20,353001191,variable,_190204,['_atom'=_190204],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(989,19),line_char(989,24))). -user:metta_file_buffer(20,353001191,variable,_191488,['_args'=_191488],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(989,25),line_char(989,30))). -user:metta_file_buffer(20,353001191,variable,_192874,['_arg_types'=_192874],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(989,31),line_char(989,41))). -user:metta_file_buffer(20,353001191,variable,_194244,['_ret_type'=_194244],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(989,42),line_char(989,51))). -user:metta_file_buffer(20,353001191,variable,_195552,['_space'=_195552],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(989,52),line_char(989,58))). -user:metta_file_buffer(19,353001191,indexed(metta_other,['interpret-args',_196410,_196432,_196454,_196476,_196498]),['interpret-args',_196550,_196556,_196562,_196568,_196574],['_space'=_196574,'_ret_type'=_196568,'_arg_types'=_196562,'_args'=_196556,'_atom'=_196550],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(989,3),line_char(989,59))). -user:metta_file_buffer(20,353001192,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(990,3),line_char(990,11))). -user:metta_file_buffer(21,353001193,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(990,13),line_char(990,21))). -user:metta_file_buffer(21,353001193,variable,_199198,['_args'=_199198],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(990,22),line_char(990,27))). -user:metta_file_buffer(21,353001194,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(990,28),line_char(990,30))). -user:metta_file_buffer(22,353001195,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(991,5),line_char(991,9))). -user:metta_file_buffer(23,353001196,constant,'if-decons',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(991,11),line_char(991,20))). -user:metta_file_buffer(23,353001196,variable,_202810,['_arg_types'=_202810],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(991,21),line_char(991,31))). -user:metta_file_buffer(23,353001196,variable,_204314,['_actual_ret_type'=_204314],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(991,32),line_char(991,48))). -user:metta_file_buffer(23,353001196,variable,_205700,['_type_tail'=_205700],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(991,49),line_char(991,59))). -user:metta_file_buffer(24,353001197,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(992,7),line_char(992,12))). -user:metta_file_buffer(25,353001198,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(992,14),line_char(992,18))). -user:metta_file_buffer(26,353001199,constant,==,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(992,20),line_char(992,22))). -user:metta_file_buffer(26,353001200,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(992,23),line_char(992,25))). -user:metta_file_buffer(26,353001200,variable,_210126,['_type_tail'=_210126],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(992,26),line_char(992,36))). -user:metta_file_buffer(25,353001200,indexed(metta_other,[==,[],_210974]),[==,[],_211032],['_type_tail'=_211032],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(992,19),line_char(992,37))). -user:metta_file_buffer(24,353001200,indexed(metta_other,[eval,[==,[],_211578]]),[eval,[==,[],_211648]],['_type_tail'=_211648],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(992,13),line_char(992,38))). -user:metta_file_buffer(24,353001200,variable,_212856,['_correct_type_len'=_212856],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(992,39),line_char(992,56))). -user:metta_file_buffer(25,353001201,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(993,9),line_char(993,13))). -user:metta_file_buffer(26,353001202,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(993,15),line_char(993,17))). -user:metta_file_buffer(26,353001202,variable,_215960,['_correct_type_len'=_215960],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(993,18),line_char(993,35))). -user:metta_file_buffer(27,353001203,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(994,7),line_char(994,11))). -user:metta_file_buffer(28,353001204,constant,'match-types',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(994,13),line_char(994,24))). -user:metta_file_buffer(28,353001204,variable,_219066,['_actual_ret_type'=_219066],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(994,25),line_char(994,41))). -user:metta_file_buffer(28,353001204,variable,_220436,['_ret_type'=_220436],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(994,42),line_char(994,51))). -user:metta_file_buffer(29,353001205,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(995,9),line_char(995,15))). -user:metta_file_buffer(29,353001206,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(995,16),line_char(995,18))). -user:metta_file_buffer(28,353001206,metta_other,[return,[]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(995,8),line_char(995,19))). -user:metta_file_buffer(29,353001207,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(996,9),line_char(996,15))). -user:metta_file_buffer(30,353001208,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(996,17),line_char(996,22))). -user:metta_file_buffer(30,353001208,variable,_225300,['_atom'=_225300],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(996,23),line_char(996,28))). -user:metta_file_buffer(30,353001208,constant,'BadType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(996,29),line_char(996,36))). -user:metta_file_buffer(29,353001208,indexed(metta_other,['Error',_226766,'BadType']),['Error',_226826,'BadType'],['_atom'=_226826],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(996,16),line_char(996,37))). -user:metta_file_buffer(28,353001208,indexed(metta_other,[return,['Error',_227364,'BadType']]),[return,['Error',_227436,'BadType']],['_atom'=_227436],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(996,8),line_char(996,38))). -user:metta_file_buffer(27,353001208,indexed(metta_other,['match-types',_227978,_228000,[return,[]],[return,['Error',_228078,'BadType']]]),['match-types',_228138,_228144,[return,[]],[return,['Error',_228180,'BadType']]],['_atom'=_228180,'_ret_type'=_228144,'_actual_ret_type'=_228138],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(994,12),line_char(996,40))). -user:metta_file_buffer(26,353001208,indexed(metta_other,[eval,['match-types',_228742,_228764,[return,[]],[return,['Error',_228842,'BadType']]]]),[eval,['match-types',_228914,_228920,[return,[]],[return,['Error',_228956,'BadType']]]],['_atom'=_228956,'_ret_type'=_228920,'_actual_ret_type'=_228914],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(994,6),line_char(996,41))). -user:metta_file_buffer(27,353001209,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(997,11),line_char(997,17))). -user:metta_file_buffer(28,353001210,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(997,19),line_char(997,24))). -user:metta_file_buffer(28,353001210,variable,_231522,['_atom'=_231522],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(997,25),line_char(997,30))). -user:metta_file_buffer(28,353001210,constant,'BadType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(997,31),line_char(997,38))). -user:metta_file_buffer(27,353001210,indexed(metta_other,['Error',_232988,'BadType']),['Error',_233048,'BadType'],['_atom'=_233048],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(997,18),line_char(997,39))). -user:metta_file_buffer(26,353001210,indexed(metta_other,[return,['Error',_233586,'BadType']]),[return,['Error',_233658,'BadType']],['_atom'=_233658],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(997,10),line_char(997,40))). -user:metta_file_buffer(25,353001210,indexed(metta_other,[if,_234194,[eval,['match-types',_234248,_234270,[return,[]],[return,['Error',_234348,'BadType']]]],[return,['Error',_234348,'BadType']]]),[if,_234466,[eval,['match-types',_234496,_234502,[return,[]],[return,['Error',_234538,'BadType']]]],[return,['Error',_234538,'BadType']]],['_atom'=_234538,'_ret_type'=_234502,'_actual_ret_type'=_234496,'_correct_type_len'=_234466],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(993,14),line_char(997,42))). -user:metta_file_buffer(24,353001210,indexed(metta_other,[eval,[if,_235142,[eval,['match-types',_235196,_235218,[return,[]],[return,['Error',_235296,'BadType']]]],[return,['Error',_235296,'BadType']]]]),[eval,[if,_235426,[eval,['match-types',_235456,_235462,[return,[]],[return,['Error',_235498,'BadType']]]],[return,['Error',_235498,'BadType']]]],['_atom'=_235498,'_ret_type'=_235462,'_actual_ret_type'=_235456,'_correct_type_len'=_235426],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(993,8),line_char(997,43))). -user:metta_file_buffer(23,353001210,indexed(metta_other,[chain,[eval,[==,[],_236138]],_236160,[eval,[if,_236160,[eval,['match-types',_236264,_236286,[return,[]],[return,['Error',_236364,'BadType']]]],[return,['Error',_236364,'BadType']]]]]),[chain,[eval,[==,[],_236512]],_236518,[eval,[if,_236518,[eval,['match-types',_236578,_236584,[return,[]],[return,['Error',_236620,'BadType']]]],[return,['Error',_236620,'BadType']]]]],['_atom'=_236620,'_ret_type'=_236584,'_actual_ret_type'=_236578,'_correct_type_len'=_236518,'_type_tail'=_236512],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(992,6),line_char(997,44))). -user:metta_file_buffer(24,353001211,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(998,7),line_char(998,13))). -user:metta_file_buffer(25,353001212,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(998,15),line_char(998,20))). -user:metta_file_buffer(25,353001212,variable,_239232,['_atom'=_239232],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(998,21),line_char(998,26))). -user:metta_file_buffer(25,353001212,string,"Too many arguments",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(998,27),line_char(998,47))). -user:metta_file_buffer(24,353001212,indexed(metta_other,['Error',_240812,"Too many arguments"]),['Error',_240872,"Too many arguments"],['_atom'=_240872],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(998,14),line_char(998,48))). -user:metta_file_buffer(23,353001212,indexed(metta_other,[return,['Error',_241410,"Too many arguments"]]),[return,['Error',_241482,"Too many arguments"]],['_atom'=_241482],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(998,6),line_char(998,49))). -user:metta_file_buffer(22,353001212,indexed(metta_other,['if-decons',_242030,_242052,_242074,[chain,[eval,[==,[],_242074]],_242170,[eval,[if,_242170,[eval,['match-types',_242052,_242292,[return,[]],[return,['Error',_242370,'BadType']]]],[return,['Error',_242370,'BadType']]]]],[return,['Error',_242370,"Too many arguments"]]]),['if-decons',_242546,_242552,_242558,[chain,[eval,[==,[],_242558]],_242612,[eval,[if,_242612,[eval,['match-types',_242552,_242678,[return,[]],[return,['Error',_242714,'BadType']]]],[return,['Error',_242714,'BadType']]]]],[return,['Error',_242714,"Too many arguments"]]],['_atom'=_242714,'_ret_type'=_242678,'_correct_type_len'=_242612,'_type_tail'=_242558,'_actual_ret_type'=_242552,'_arg_types'=_242546],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(991,10),line_char(998,51))). -user:metta_file_buffer(21,353001212,indexed(metta_other,[eval,['if-decons',_243372,_243394,_243416,[chain,[eval,[==,[],_243416]],_243512,[eval,[if,_243512,[eval,['match-types',_243394,_243634,[return,[]],[return,['Error',_243712,'BadType']]]],[return,['Error',_243712,'BadType']]]]],[return,['Error',_243712,"Too many arguments"]]]]),[eval,['if-decons',_243900,_243906,_243912,[chain,[eval,[==,[],_243912]],_243966,[eval,[if,_243966,[eval,['match-types',_243906,_244032,[return,[]],[return,['Error',_244068,'BadType']]]],[return,['Error',_244068,'BadType']]]]],[return,['Error',_244068,"Too many arguments"]]]],['_atom'=_244068,'_ret_type'=_244032,'_correct_type_len'=_243966,'_type_tail'=_243912,'_actual_ret_type'=_243906,'_arg_types'=_243900],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(991,4),line_char(998,52))). -user:metta_file_buffer(22,353001213,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(999,5),line_char(999,9))). -user:metta_file_buffer(23,353001214,constant,'if-decons',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(999,11),line_char(999,20))). -user:metta_file_buffer(23,353001214,variable,_246738,['_args'=_246738],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(999,21),line_char(999,26))). -user:metta_file_buffer(23,353001214,variable,_248022,['_head'=_248022],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(999,27),line_char(999,32))). -user:metta_file_buffer(23,353001214,variable,_249306,['_tail'=_249306],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(999,33),line_char(999,38))). -user:metta_file_buffer(24,353001215,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1000,7),line_char(1000,11))). -user:metta_file_buffer(25,353001216,constant,'if-decons',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1000,13),line_char(1000,22))). -user:metta_file_buffer(25,353001216,variable,_252274,['_arg_types'=_252274],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1000,23),line_char(1000,33))). -user:metta_file_buffer(25,353001216,variable,_253660,['_head_type'=_253660],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1000,34),line_char(1000,44))). -user:metta_file_buffer(25,353001216,variable,_255062,['_tail_types'=_255062],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1000,45),line_char(1000,56))). -user:metta_file_buffer(26,353001217,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1001,9),line_char(1001,14))). -user:metta_file_buffer(27,353001218,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1001,16),line_char(1001,20))). -user:metta_file_buffer(28,353001219,constant,interpret,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1001,22),line_char(1001,31))). -user:metta_file_buffer(28,353001219,variable,_258804,['_head'=_258804],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1001,32),line_char(1001,37))). -user:metta_file_buffer(28,353001219,variable,_260190,['_head_type'=_260190],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1001,38),line_char(1001,48))). -user:metta_file_buffer(28,353001219,variable,_261498,['_space'=_261498],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1001,49),line_char(1001,55))). -user:metta_file_buffer(27,353001219,indexed(metta_other,[interpret,_262344,_262366,_262388]),[interpret,_262440,_262446,_262452],['_space'=_262452,'_head_type'=_262446,'_head'=_262440],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1001,21),line_char(1001,56))). -user:metta_file_buffer(26,353001219,indexed(metta_other,[eval,[interpret,_263014,_263036,_263058]]),[eval,[interpret,_263122,_263128,_263134]],['_space'=_263134,'_head_type'=_263128,'_head'=_263122],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1001,15),line_char(1001,57))). -user:metta_file_buffer(26,353001219,variable,_264280,['_reduced_head'=_264280],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1001,58),line_char(1001,71))). -user:metta_file_buffer(26,353001219,indexed(metta_comment,"; check that head was changed otherwise Error or Empty in the head"),'$COMMENT'("; check that head was changed otherwise Error or Empty in the head",1002,10),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1002,10),line_char(1002,76))). -user:metta_file_buffer(26,353001219,indexed(metta_comment,"; can be just an argument which is passed by intention"),'$COMMENT'("; can be just an argument which is passed by intention",1003,10),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1003,10),line_char(1003,64))). -user:metta_file_buffer(27,353001220,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1004,11),line_char(1004,15))). -user:metta_file_buffer(28,353001221,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1004,17),line_char(1004,25))). -user:metta_file_buffer(28,353001221,variable,_268558,['_reduced_head'=_268558],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1004,26),line_char(1004,39))). -user:metta_file_buffer(28,353001221,variable,_269842,['_head'=_269842],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1004,40),line_char(1004,45))). -user:metta_file_buffer(29,353001222,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,13),line_char(1005,18))). -user:metta_file_buffer(30,353001223,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,20),line_char(1005,24))). -user:metta_file_buffer(31,353001224,constant,'interpret-args-tail',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,26),line_char(1005,45))). -user:metta_file_buffer(31,353001224,variable,_273624,['_atom'=_273624],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,46),line_char(1005,51))). -user:metta_file_buffer(31,353001224,variable,_275058,['_reduced_head'=_275058],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,52),line_char(1005,65))). -user:metta_file_buffer(31,353001224,variable,_276342,['_tail'=_276342],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,66),line_char(1005,71))). -user:metta_file_buffer(31,353001224,variable,_277744,['_tail_types'=_277744],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,72),line_char(1005,83))). -user:metta_file_buffer(31,353001224,variable,_279114,['_ret_type'=_279114],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,84),line_char(1005,93))). -user:metta_file_buffer(31,353001224,variable,_280422,['_space'=_280422],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,94),line_char(1005,100))). -user:metta_file_buffer(30,353001224,indexed(metta_other,['interpret-args-tail',_281286,_281308,_281330,_281352,_281374,_281396]),['interpret-args-tail',_281448,_281454,_281460,_281466,_281472,_281478],['_space'=_281478,'_ret_type'=_281472,'_tail_types'=_281466,'_tail'=_281460,'_reduced_head'=_281454,'_atom'=_281448],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,25),line_char(1005,101))). -user:metta_file_buffer(29,353001224,indexed(metta_other,[eval,['interpret-args-tail',_282076,_282098,_282120,_282142,_282164,_282186]]),[eval,['interpret-args-tail',_282250,_282256,_282262,_282268,_282274,_282280]],['_space'=_282280,'_ret_type'=_282274,'_tail_types'=_282268,'_tail'=_282262,'_reduced_head'=_282256,'_atom'=_282250],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,19),line_char(1005,102))). -user:metta_file_buffer(29,353001224,variable,_283296,['_ret'=_283296],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,103),line_char(1005,107))). -user:metta_file_buffer(30,353001225,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,109),line_char(1005,115))). -user:metta_file_buffer(30,353001225,variable,_285386,['_ret'=_285386],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,116),line_char(1005,120))). -user:metta_file_buffer(29,353001225,indexed(metta_other,[return,_286220]),[return,_286272],['_ret'=_286272],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,108),line_char(1005,121))). -user:metta_file_buffer(28,353001225,indexed(metta_other,[chain,[eval,['interpret-args-tail',_286838,_286860,_286882,_286904,_286926,_286948]],_286970,[return,_286970]]),[chain,[eval,['interpret-args-tail',_287080,_287086,_287092,_287098,_287104,_287110]],_287116,[return,_287116]],['_ret'=_287116,'_space'=_287110,'_ret_type'=_287104,'_tail_types'=_287098,'_tail'=_287092,'_reduced_head'=_287086,'_atom'=_287080],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1005,12),line_char(1005,122))). -user:metta_file_buffer(29,353001226,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1006,13),line_char(1006,17))). -user:metta_file_buffer(30,353001227,constant,'return-on-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1006,19),line_char(1006,34))). -user:metta_file_buffer(30,353001227,variable,_289982,['_reduced_head'=_289982],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1006,35),line_char(1006,48))). -user:metta_file_buffer(31,353001228,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,15),line_char(1007,20))). -user:metta_file_buffer(32,353001229,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,22),line_char(1007,26))). -user:metta_file_buffer(33,353001230,constant,'interpret-args-tail',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,28),line_char(1007,47))). -user:metta_file_buffer(33,353001230,variable,_293768,['_atom'=_293768],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,48),line_char(1007,53))). -user:metta_file_buffer(33,353001230,variable,_295202,['_reduced_head'=_295202],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,54),line_char(1007,67))). -user:metta_file_buffer(33,353001230,variable,_296486,['_tail'=_296486],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,68),line_char(1007,73))). -user:metta_file_buffer(33,353001230,variable,_297888,['_tail_types'=_297888],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,74),line_char(1007,85))). -user:metta_file_buffer(33,353001230,variable,_299258,['_ret_type'=_299258],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,86),line_char(1007,95))). -user:metta_file_buffer(33,353001230,variable,_300566,['_space'=_300566],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,96),line_char(1007,102))). -user:metta_file_buffer(32,353001230,indexed(metta_other,['interpret-args-tail',_301430,_301452,_301474,_301496,_301518,_301540]),['interpret-args-tail',_301592,_301598,_301604,_301610,_301616,_301622],['_space'=_301622,'_ret_type'=_301616,'_tail_types'=_301610,'_tail'=_301604,'_reduced_head'=_301598,'_atom'=_301592],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,27),line_char(1007,103))). -user:metta_file_buffer(31,353001230,indexed(metta_other,[eval,['interpret-args-tail',_302220,_302242,_302264,_302286,_302308,_302330]]),[eval,['interpret-args-tail',_302394,_302400,_302406,_302412,_302418,_302424]],['_space'=_302424,'_ret_type'=_302418,'_tail_types'=_302412,'_tail'=_302406,'_reduced_head'=_302400,'_atom'=_302394],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,21),line_char(1007,104))). -user:metta_file_buffer(31,353001230,variable,_303440,['_ret'=_303440],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,105),line_char(1007,109))). -user:metta_file_buffer(32,353001231,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,111),line_char(1007,117))). -user:metta_file_buffer(32,353001231,variable,_305530,['_ret'=_305530],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,118),line_char(1007,122))). -user:metta_file_buffer(31,353001231,indexed(metta_other,[return,_306364]),[return,_306416],['_ret'=_306416],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,110),line_char(1007,123))). -user:metta_file_buffer(30,353001231,indexed(metta_other,[chain,[eval,['interpret-args-tail',_306982,_307004,_307026,_307048,_307070,_307092]],_307114,[return,_307114]]),[chain,[eval,['interpret-args-tail',_307224,_307230,_307236,_307242,_307248,_307254]],_307260,[return,_307260]],['_ret'=_307260,'_space'=_307254,'_ret_type'=_307248,'_tail_types'=_307242,'_tail'=_307236,'_reduced_head'=_307230,'_atom'=_307224],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1007,14),line_char(1007,124))). -user:metta_file_buffer(29,353001231,indexed(metta_other,['return-on-error',_307880,[chain,[eval,['interpret-args-tail',_307950,_307880,_307990,_308012,_308034,_308056]],_308078,[return,_308078]]]),['return-on-error',_308164,[chain,[eval,['interpret-args-tail',_308206,_308164,_308218,_308224,_308230,_308236]],_308242,[return,_308242]]],['_ret'=_308242,'_space'=_308236,'_ret_type'=_308230,'_tail_types'=_308224,'_tail'=_308218,'_atom'=_308206,'_reduced_head'=_308164],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1006,18),line_char(1007,126))). -user:metta_file_buffer(28,353001231,indexed(metta_other,[eval,['return-on-error',_308870,[chain,[eval,['interpret-args-tail',_308940,_308870,_308980,_309002,_309024,_309046]],_309068,[return,_309068]]]]),[eval,['return-on-error',_309166,[chain,[eval,['interpret-args-tail',_309208,_309166,_309220,_309226,_309232,_309238]],_309244,[return,_309244]]]],['_ret'=_309244,'_space'=_309238,'_ret_type'=_309232,'_tail_types'=_309226,'_tail'=_309220,'_atom'=_309208,'_reduced_head'=_309166],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1006,12),line_char(1007,127))). -user:metta_file_buffer(27,353001231,indexed(metta_other,['if-equal',_309874,_309896,[chain,[eval,['interpret-args-tail',_309966,_309874,_310006,_310028,_310050,_310072]],_310094,[return,_310094]],[eval,['return-on-error',_309874,[chain,[eval,['interpret-args-tail',_309966,_309874,_310006,_310028,_310050,_310072]],_310094,[return,_310094]]]]]),['if-equal',_310438,_310444,[chain,[eval,['interpret-args-tail',_310486,_310438,_310498,_310504,_310510,_310516]],_310522,[return,_310522]],[eval,['return-on-error',_310438,[chain,[eval,['interpret-args-tail',_310486,_310438,_310498,_310504,_310510,_310516]],_310522,[return,_310522]]]]],['_ret'=_310522,'_space'=_310516,'_ret_type'=_310510,'_tail_types'=_310504,'_tail'=_310498,'_atom'=_310486,'_head'=_310444,'_reduced_head'=_310438],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1004,16),line_char(1007,128))). -user:metta_file_buffer(26,353001231,indexed(metta_other,[eval,['if-equal',_311288,_311310,[chain,[eval,['interpret-args-tail',_311380,_311288,_311420,_311442,_311464,_311486]],_311508,[return,_311508]],[eval,['return-on-error',_311288,[chain,[eval,['interpret-args-tail',_311380,_311288,_311420,_311442,_311464,_311486]],_311508,[return,_311508]]]]]]),[eval,['if-equal',_311864,_311870,[chain,[eval,['interpret-args-tail',_311912,_311864,_311924,_311930,_311936,_311942]],_311948,[return,_311948]],[eval,['return-on-error',_311864,[chain,[eval,['interpret-args-tail',_311912,_311864,_311924,_311930,_311936,_311942]],_311948,[return,_311948]]]]]],['_ret'=_311948,'_space'=_311942,'_ret_type'=_311936,'_tail_types'=_311930,'_tail'=_311924,'_atom'=_311912,'_head'=_311870,'_reduced_head'=_311864],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1004,10),line_char(1007,129))). -user:metta_file_buffer(25,353001231,indexed(metta_other,[chain,[eval,[interpret,_312742,_312764,_312786]],_312808,[eval,['if-equal',_312808,_312742,[chain,[eval,['interpret-args-tail',_312946,_312808,_312986,_313008,_313030,_312786]],_313070,[return,_313070]],[eval,['return-on-error',_312808,[chain,[eval,['interpret-args-tail',_312946,_312808,_312986,_313008,_313030,_312786]],_313070,[return,_313070]]]]]]]),[chain,[eval,[interpret,_313438,_313444,_313450]],_313456,[eval,['if-equal',_313456,_313438,[chain,[eval,['interpret-args-tail',_313534,_313456,_313546,_313552,_313558,_313450]],_313570,[return,_313570]],[eval,['return-on-error',_313456,[chain,[eval,['interpret-args-tail',_313534,_313456,_313546,_313552,_313558,_313450]],_313570,[return,_313570]]]]]]],['_ret'=_313570,'_ret_type'=_313558,'_tail_types'=_313552,'_tail'=_313546,'_atom'=_313534,'_reduced_head'=_313456,'_space'=_313450,'_head_type'=_313444,'_head'=_313438],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1001,8),line_char(1007,130))). -user:metta_file_buffer(26,353001232,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1008,9),line_char(1008,15))). -user:metta_file_buffer(27,353001233,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1008,17),line_char(1008,22))). -user:metta_file_buffer(27,353001233,variable,_316348,['_atom'=_316348],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1008,23),line_char(1008,28))). -user:metta_file_buffer(27,353001233,constant,'BadType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1008,29),line_char(1008,36))). -user:metta_file_buffer(26,353001233,indexed(metta_other,['Error',_317814,'BadType']),['Error',_317874,'BadType'],['_atom'=_317874],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1008,16),line_char(1008,37))). -user:metta_file_buffer(25,353001233,indexed(metta_other,[return,['Error',_318412,'BadType']]),[return,['Error',_318484,'BadType']],['_atom'=_318484],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1008,8),line_char(1008,38))). -user:metta_file_buffer(24,353001233,indexed(metta_other,['if-decons',_319032,_319054,_319076,[chain,[eval,[interpret,_319146,_319054,_319186]],_319208,[eval,['if-equal',_319208,_319146,[chain,[eval,['interpret-args-tail',_319346,_319208,_319386,_319076,_319426,_319186]],_319466,[return,_319466]],[eval,['return-on-error',_319208,[chain,[eval,['interpret-args-tail',_319346,_319208,_319386,_319076,_319426,_319186]],_319466,[return,_319466]]]]]]],[return,['Error',_319346,'BadType']]]),['if-decons',_319868,_319874,_319880,[chain,[eval,[interpret,_319922,_319874,_319934]],_319940,[eval,['if-equal',_319940,_319922,[chain,[eval,['interpret-args-tail',_320018,_319940,_320030,_319880,_320042,_319934]],_320054,[return,_320054]],[eval,['return-on-error',_319940,[chain,[eval,['interpret-args-tail',_320018,_319940,_320030,_319880,_320042,_319934]],_320054,[return,_320054]]]]]]],[return,['Error',_320018,'BadType']]],['_ret'=_320054,'_ret_type'=_320042,'_tail'=_320030,'_atom'=_320018,'_reduced_head'=_319940,'_space'=_319934,'_head'=_319922,'_tail_types'=_319880,'_head_type'=_319874,'_arg_types'=_319868],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1000,12),line_char(1008,40))). -user:metta_file_buffer(23,353001233,indexed(metta_other,[eval,['if-decons',_320874,_320896,_320918,[chain,[eval,[interpret,_320988,_320896,_321028]],_321050,[eval,['if-equal',_321050,_320988,[chain,[eval,['interpret-args-tail',_321188,_321050,_321228,_320918,_321268,_321028]],_321308,[return,_321308]],[eval,['return-on-error',_321050,[chain,[eval,['interpret-args-tail',_321188,_321050,_321228,_320918,_321268,_321028]],_321308,[return,_321308]]]]]]],[return,['Error',_321188,'BadType']]]]),[eval,['if-decons',_321722,_321728,_321734,[chain,[eval,[interpret,_321776,_321728,_321788]],_321794,[eval,['if-equal',_321794,_321776,[chain,[eval,['interpret-args-tail',_321872,_321794,_321884,_321734,_321896,_321788]],_321908,[return,_321908]],[eval,['return-on-error',_321794,[chain,[eval,['interpret-args-tail',_321872,_321794,_321884,_321734,_321896,_321788]],_321908,[return,_321908]]]]]]],[return,['Error',_321872,'BadType']]]],['_ret'=_321908,'_ret_type'=_321896,'_tail'=_321884,'_atom'=_321872,'_reduced_head'=_321794,'_space'=_321788,'_head'=_321776,'_tail_types'=_321734,'_head_type'=_321728,'_arg_types'=_321722],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1000,6),line_char(1008,41))). -user:metta_file_buffer(24,353001234,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1009,7),line_char(1009,13))). -user:metta_file_buffer(25,353001235,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1009,15),line_char(1009,20))). -user:metta_file_buffer(26,353001236,constant,'interpret-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1009,22),line_char(1009,36))). -user:metta_file_buffer(26,353001236,variable,_325550,['_atom'=_325550],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1009,37),line_char(1009,42))). -user:metta_file_buffer(26,353001236,variable,_326834,['_args'=_326834],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1009,43),line_char(1009,48))). -user:metta_file_buffer(26,353001236,variable,_328220,['_arg_types'=_328220],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1009,49),line_char(1009,59))). -user:metta_file_buffer(26,353001236,variable,_329528,['_space'=_329528],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1009,60),line_char(1009,66))). -user:metta_file_buffer(25,353001236,indexed(metta_other,['interpret-atom',_330380,_330402,_330424,_330446]),['interpret-atom',_330498,_330504,_330510,_330516],['_space'=_330516,'_arg_types'=_330510,'_args'=_330504,'_atom'=_330498],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1009,21),line_char(1009,67))). -user:metta_file_buffer(25,353001236,string,"Non-empty expression atom is expected",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1009,68),line_char(1009,107))). -user:metta_file_buffer(24,353001236,indexed(metta_other,['Error',['interpret-atom',_332030,_332052,_332074,_332096],"Non-empty expression atom is expected"]),['Error',['interpret-atom',_332168,_332174,_332180,_332186],"Non-empty expression atom is expected"],['_space'=_332186,'_arg_types'=_332180,'_args'=_332174,'_atom'=_332168],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1009,14),line_char(1009,108))). -user:metta_file_buffer(23,353001236,indexed(metta_other,[return,['Error',['interpret-atom',_332776,_332798,_332820,_332842],"Non-empty expression atom is expected"]]),[return,['Error',['interpret-atom',_332926,_332932,_332938,_332944],"Non-empty expression atom is expected"]],['_space'=_332944,'_arg_types'=_332938,'_args'=_332932,'_atom'=_332926],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1009,6),line_char(1009,109))). -user:metta_file_buffer(22,353001236,indexed(metta_other,['if-decons',_333528,_333550,_333572,[eval,['if-decons',_333626,_333648,_333670,[chain,[eval,[interpret,_333550,_333648,_333776]],_333798,[eval,['if-equal',_333798,_333550,[chain,[eval,['interpret-args-tail',_333936,_333798,_333572,_333670,_334012,_333776]],_334052,[return,_334052]],[eval,['return-on-error',_333798,[chain,[eval,['interpret-args-tail',_333936,_333798,_333572,_333670,_334012,_333776]],_334052,[return,_334052]]]]]]],[return,['Error',_333936,'BadType']]]],[return,['Error',['interpret-atom',_333936,_333528,_333626,_333776],"Non-empty expression atom is expected"]]]),['if-decons',_334582,_334588,_334594,[eval,['if-decons',_334624,_334630,_334636,[chain,[eval,[interpret,_334588,_334630,_334690]],_334696,[eval,['if-equal',_334696,_334588,[chain,[eval,['interpret-args-tail',_334774,_334696,_334594,_334636,_334798,_334690]],_334810,[return,_334810]],[eval,['return-on-error',_334696,[chain,[eval,['interpret-args-tail',_334774,_334696,_334594,_334636,_334798,_334690]],_334810,[return,_334810]]]]]]],[return,['Error',_334774,'BadType']]]],[return,['Error',['interpret-atom',_334774,_334582,_334624,_334690],"Non-empty expression atom is expected"]]],['_ret'=_334810,'_ret_type'=_334798,'_atom'=_334774,'_reduced_head'=_334696,'_space'=_334690,'_tail_types'=_334636,'_head_type'=_334630,'_arg_types'=_334624,'_tail'=_334594,'_head'=_334588,'_args'=_334582],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(999,10),line_char(1009,111))). -user:metta_file_buffer(21,353001236,indexed(metta_other,[eval,['if-decons',_335702,_335724,_335746,[eval,['if-decons',_335800,_335822,_335844,[chain,[eval,[interpret,_335724,_335822,_335950]],_335972,[eval,['if-equal',_335972,_335724,[chain,[eval,['interpret-args-tail',_336110,_335972,_335746,_335844,_336186,_335950]],_336226,[return,_336226]],[eval,['return-on-error',_335972,[chain,[eval,['interpret-args-tail',_336110,_335972,_335746,_335844,_336186,_335950]],_336226,[return,_336226]]]]]]],[return,['Error',_336110,'BadType']]]],[return,['Error',['interpret-atom',_336110,_335702,_335800,_335950],"Non-empty expression atom is expected"]]]]),[eval,['if-decons',_336768,_336774,_336780,[eval,['if-decons',_336810,_336816,_336822,[chain,[eval,[interpret,_336774,_336816,_336876]],_336882,[eval,['if-equal',_336882,_336774,[chain,[eval,['interpret-args-tail',_336960,_336882,_336780,_336822,_336984,_336876]],_336996,[return,_336996]],[eval,['return-on-error',_336882,[chain,[eval,['interpret-args-tail',_336960,_336882,_336780,_336822,_336984,_336876]],_336996,[return,_336996]]]]]]],[return,['Error',_336960,'BadType']]]],[return,['Error',['interpret-atom',_336960,_336768,_336810,_336876],"Non-empty expression atom is expected"]]]],['_ret'=_336996,'_ret_type'=_336984,'_atom'=_336960,'_reduced_head'=_336882,'_space'=_336876,'_tail_types'=_336822,'_head_type'=_336816,'_arg_types'=_336810,'_tail'=_336780,'_head'=_336774,'_args'=_336768],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(999,4),line_char(1009,112))). -user:metta_file_buffer(20,353001236,indexed(metta_other,['if-unify',_337890,[],[eval,['if-decons',_337952,_337974,_337996,[chain,[eval,[==,[],_337996]],_338092,[eval,[if,_338092,[eval,['match-types',_337974,_338214,[return,[]],[return,['Error',_338292,'BadType']]]],[return,['Error',_338292,'BadType']]]]],[return,['Error',_338292,"Too many arguments"]]]],[eval,['if-decons',_337890,_338488,_338510,[eval,['if-decons',_337952,_338582,_338604,[chain,[eval,[interpret,_338488,_338582,_338710]],_338732,[eval,['if-equal',_338732,_338488,[chain,[eval,['interpret-args-tail',_338292,_338732,_338510,_338604,_338214,_338710]],_338978,[return,_338978]],[eval,['return-on-error',_338732,[chain,[eval,['interpret-args-tail',_338292,_338732,_338510,_338604,_338214,_338710]],_338978,[return,_338978]]]]]]],[return,['Error',_338292,'BadType']]]],[return,['Error',['interpret-atom',_338292,_337890,_337952,_338710],"Non-empty expression atom is expected"]]]]]),['if-unify',_339508,[],[eval,['if-decons',_339544,_339550,_339556,[chain,[eval,[==,[],_339556]],_339610,[eval,[if,_339610,[eval,['match-types',_339550,_339676,[return,[]],[return,['Error',_339712,'BadType']]]],[return,['Error',_339712,'BadType']]]]],[return,['Error',_339712,"Too many arguments"]]]],[eval,['if-decons',_339508,_339808,_339814,[eval,['if-decons',_339544,_339850,_339856,[chain,[eval,[interpret,_339808,_339850,_339910]],_339916,[eval,['if-equal',_339916,_339808,[chain,[eval,['interpret-args-tail',_339712,_339916,_339814,_339856,_339676,_339910]],_340030,[return,_340030]],[eval,['return-on-error',_339916,[chain,[eval,['interpret-args-tail',_339712,_339916,_339814,_339856,_339676,_339910]],_340030,[return,_340030]]]]]]],[return,['Error',_339712,'BadType']]]],[return,['Error',['interpret-atom',_339712,_339508,_339544,_339910],"Non-empty expression atom is expected"]]]]],['_ret'=_340030,'_reduced_head'=_339916,'_space'=_339910,'_tail_types'=_339856,'_head_type'=_339850,'_tail'=_339814,'_head'=_339808,'_atom'=_339712,'_ret_type'=_339676,'_correct_type_len'=_339610,'_type_tail'=_339556,'_actual_ret_type'=_339550,'_arg_types'=_339544,'_args'=_339508],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(990,12),line_char(1009,113))). -user:metta_file_buffer(19,353001236,indexed(metta_other,[function,['if-unify',_340958,[],[eval,['if-decons',_341020,_341042,_341064,[chain,[eval,[==,[],_341064]],_341160,[eval,[if,_341160,[eval,['match-types',_341042,_341282,[return,[]],[return,['Error',_341360,'BadType']]]],[return,['Error',_341360,'BadType']]]]],[return,['Error',_341360,"Too many arguments"]]]],[eval,['if-decons',_340958,_341556,_341578,[eval,['if-decons',_341020,_341650,_341672,[chain,[eval,[interpret,_341556,_341650,_341778]],_341800,[eval,['if-equal',_341800,_341556,[chain,[eval,['interpret-args-tail',_341360,_341800,_341578,_341672,_341282,_341778]],_342046,[return,_342046]],[eval,['return-on-error',_341800,[chain,[eval,['interpret-args-tail',_341360,_341800,_341578,_341672,_341282,_341778]],_342046,[return,_342046]]]]]]],[return,['Error',_341360,'BadType']]]],[return,['Error',['interpret-atom',_341360,_340958,_341020,_341778],"Non-empty expression atom is expected"]]]]]]),[function,['if-unify',_342588,[],[eval,['if-decons',_342624,_342630,_342636,[chain,[eval,[==,[],_342636]],_342690,[eval,[if,_342690,[eval,['match-types',_342630,_342756,[return,[]],[return,['Error',_342792,'BadType']]]],[return,['Error',_342792,'BadType']]]]],[return,['Error',_342792,"Too many arguments"]]]],[eval,['if-decons',_342588,_342888,_342894,[eval,['if-decons',_342624,_342930,_342936,[chain,[eval,[interpret,_342888,_342930,_342990]],_342996,[eval,['if-equal',_342996,_342888,[chain,[eval,['interpret-args-tail',_342792,_342996,_342894,_342936,_342756,_342990]],_343110,[return,_343110]],[eval,['return-on-error',_342996,[chain,[eval,['interpret-args-tail',_342792,_342996,_342894,_342936,_342756,_342990]],_343110,[return,_343110]]]]]]],[return,['Error',_342792,'BadType']]]],[return,['Error',['interpret-atom',_342792,_342588,_342624,_342990],"Non-empty expression atom is expected"]]]]]],['_ret'=_343110,'_reduced_head'=_342996,'_space'=_342990,'_tail_types'=_342936,'_head_type'=_342930,'_tail'=_342894,'_head'=_342888,'_atom'=_342792,'_ret_type'=_342756,'_correct_type_len'=_342690,'_type_tail'=_342636,'_actual_ret_type'=_342630,'_arg_types'=_342624,'_args'=_342588],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(990,2),line_char(1009,114))). -user:metta_file_buffer(18,353001236,indexed(metta_defun,['interpret-args',_344044,_344066,_344088,_344110,_344132]),[=,['interpret-args',_345796,_345802,_345808,_345814,_345820],[function,['if-unify',_345802,[],[eval,['if-decons',_345808,_345892,_345898,[chain,[eval,[==,[],_345898]],_345952,[eval,[if,_345952,[eval,['match-types',_345892,_345814,[return,[]],[return,['Error',_345796,'BadType']]]],[return,['Error',_345796,'BadType']]]]],[return,['Error',_345796,"Too many arguments"]]]],[eval,['if-decons',_345802,_346150,_346156,[eval,['if-decons',_345808,_346192,_346198,[chain,[eval,[interpret,_346150,_346192,_345820]],_346258,[eval,['if-equal',_346258,_346150,[chain,[eval,['interpret-args-tail',_345796,_346258,_346156,_346198,_345814,_345820]],_346372,[return,_346372]],[eval,['return-on-error',_346258,[chain,[eval,['interpret-args-tail',_345796,_346258,_346156,_346198,_345814,_345820]],_346372,[return,_346372]]]]]]],[return,['Error',_345796,'BadType']]]],[return,['Error',['interpret-atom',_345796,_345802,_345808,_345820],"Non-empty expression atom is expected"]]]]]]],['_ret'=_346372,'_reduced_head'=_346258,'_tail_types'=_346198,'_head_type'=_346192,'_tail'=_346156,'_head'=_346150,'_correct_type_len'=_345952,'_type_tail'=_345898,'_actual_ret_type'=_345892,'_space'=_345820,'_ret_type'=_345814,'_arg_types'=_345808,'_args'=_345802,'_atom'=_345796],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(989,0),line_char(1009,115))). -user:metta_file_buffer(19,354001237,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1011,1),line_char(1011,3))). -user:metta_file_buffer(19,354001237,constant,'interpret-args-tail',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1011,4),line_char(1011,23))). -user:metta_file_buffer(19,354001237,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1011,24),line_char(1011,42))). -user:metta_file_buffer(18,354001237,metta_other,[iz,'interpret-args-tail','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1011,0),line_char(1011,43))). -user:metta_file_buffer(19,355001238,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1012,1),line_char(1012,2))). -user:metta_file_buffer(20,355001239,constant,'interpret-args-tail',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1012,4),line_char(1012,23))). -user:metta_file_buffer(20,355001239,variable,_190254,['_atom'=_190254],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1012,24),line_char(1012,29))). -user:metta_file_buffer(20,355001239,variable,_191538,['_head'=_191538],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1012,30),line_char(1012,35))). -user:metta_file_buffer(20,355001239,variable,_192924,['_args_tail'=_192924],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1012,36),line_char(1012,46))). -user:metta_file_buffer(20,355001239,variable,_194428,['_args_tail_types'=_194428],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1012,47),line_char(1012,63))). -user:metta_file_buffer(20,355001239,variable,_195798,['_ret_type'=_195798],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1012,64),line_char(1012,73))). -user:metta_file_buffer(20,355001239,variable,_197106,['_space'=_197106],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1012,74),line_char(1012,80))). -user:metta_file_buffer(19,355001239,indexed(metta_other,['interpret-args-tail',_197970,_197992,_198014,_198036,_198058,_198080]),['interpret-args-tail',_198132,_198138,_198144,_198150,_198156,_198162],['_space'=_198162,'_ret_type'=_198156,'_args_tail_types'=_198150,'_args_tail'=_198144,'_head'=_198138,'_atom'=_198132],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1012,3),line_char(1012,81))). -user:metta_file_buffer(20,355001240,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,3),line_char(1013,11))). -user:metta_file_buffer(21,355001241,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,13),line_char(1013,18))). -user:metta_file_buffer(22,355001242,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,20),line_char(1013,24))). -user:metta_file_buffer(23,355001243,constant,'interpret-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,26),line_char(1013,40))). -user:metta_file_buffer(23,355001243,variable,_202456,['_atom'=_202456],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,41),line_char(1013,46))). -user:metta_file_buffer(23,355001243,variable,_203842,['_args_tail'=_203842],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,47),line_char(1013,57))). -user:metta_file_buffer(23,355001243,variable,_205346,['_args_tail_types'=_205346],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,58),line_char(1013,74))). -user:metta_file_buffer(23,355001243,variable,_206716,['_ret_type'=_206716],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,75),line_char(1013,84))). -user:metta_file_buffer(23,355001243,variable,_208024,['_space'=_208024],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,85),line_char(1013,91))). -user:metta_file_buffer(22,355001243,indexed(metta_other,['interpret-args',_208882,_208904,_208926,_208948,_208970]),['interpret-args',_209022,_209028,_209034,_209040,_209046],['_space'=_209046,'_ret_type'=_209040,'_args_tail_types'=_209034,'_args_tail'=_209028,'_atom'=_209022],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,25),line_char(1013,92))). -user:metta_file_buffer(21,355001243,indexed(metta_other,[eval,['interpret-args',_209632,_209654,_209676,_209698,_209720]]),[eval,['interpret-args',_209784,_209790,_209796,_209802,_209808]],['_space'=_209808,'_ret_type'=_209802,'_args_tail_types'=_209796,'_args_tail'=_209790,'_atom'=_209784],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,19),line_char(1013,93))). -user:metta_file_buffer(21,355001243,variable,_210978,['_reduced_tail'=_210978],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,94),line_char(1013,107))). -user:metta_file_buffer(22,355001244,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1014,5),line_char(1014,9))). -user:metta_file_buffer(23,355001245,constant,'return-on-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1014,11),line_char(1014,26))). -user:metta_file_buffer(23,355001245,variable,_214050,['_reduced_tail'=_214050],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1014,27),line_char(1014,40))). -user:metta_file_buffer(24,355001246,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1015,7),line_char(1015,12))). -user:metta_file_buffer(25,355001247,constant,'cons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1015,14),line_char(1015,23))). -user:metta_file_buffer(25,355001247,variable,_216926,['_head'=_216926],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1015,24),line_char(1015,29))). -user:metta_file_buffer(25,355001247,variable,_218368,['_reduced_tail'=_218368],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1015,30),line_char(1015,43))). -user:metta_file_buffer(24,355001247,indexed(metta_other,['cons-atom',_219208,_219230]),['cons-atom',_219282,_219288],['_reduced_tail'=_219288,'_head'=_219282],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1015,13),line_char(1015,44))). -user:metta_file_buffer(24,355001247,variable,_220256,['_ret'=_220256],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1015,45),line_char(1015,49))). -user:metta_file_buffer(25,355001248,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1015,51),line_char(1015,57))). -user:metta_file_buffer(25,355001248,variable,_222346,['_ret'=_222346],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1015,58),line_char(1015,62))). -user:metta_file_buffer(24,355001248,indexed(metta_other,[return,_223180]),[return,_223232],['_ret'=_223232],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1015,50),line_char(1015,63))). -user:metta_file_buffer(23,355001248,indexed(metta_other,[chain,['cons-atom',_223782,_223804],_223826,[return,_223826]]),[chain,['cons-atom',_223924,_223930],_223936,[return,_223936]],['_ret'=_223936,'_reduced_tail'=_223930,'_head'=_223924],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1015,6),line_char(1015,64))). -user:metta_file_buffer(22,355001248,indexed(metta_other,['return-on-error',_224508,[chain,['cons-atom',_224562,_224508],_224602,[return,_224602]]]),['return-on-error',_224688,[chain,['cons-atom',_224718,_224688],_224730,[return,_224730]]],['_ret'=_224730,'_head'=_224718,'_reduced_tail'=_224688],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1014,10),line_char(1015,66))). -user:metta_file_buffer(21,355001248,indexed(metta_other,[eval,['return-on-error',_225310,[chain,['cons-atom',_225364,_225310],_225404,[return,_225404]]]]),[eval,['return-on-error',_225502,[chain,['cons-atom',_225532,_225502],_225544,[return,_225544]]]],['_ret'=_225544,'_head'=_225532,'_reduced_tail'=_225502],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1014,4),line_char(1015,67))). -user:metta_file_buffer(20,355001248,indexed(metta_other,[chain,[eval,['interpret-args',_226152,_226174,_226196,_226218,_226240]],_226262,[eval,['return-on-error',_226262,[chain,['cons-atom',_226366,_226262],_226406,[return,_226406]]]]]),[chain,[eval,['interpret-args',_226516,_226522,_226528,_226534,_226540]],_226546,[eval,['return-on-error',_226546,[chain,['cons-atom',_226606,_226546],_226618,[return,_226618]]]]],['_ret'=_226618,'_head'=_226606,'_reduced_tail'=_226546,'_space'=_226540,'_ret_type'=_226534,'_args_tail_types'=_226528,'_args_tail'=_226522,'_atom'=_226516],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,12),line_char(1015,68))). -user:metta_file_buffer(19,355001248,indexed(metta_other,[function,[chain,[eval,['interpret-args',_227290,_227312,_227334,_227356,_227378]],_227400,[eval,['return-on-error',_227400,[chain,['cons-atom',_227504,_227400],_227544,[return,_227544]]]]]]),[function,[chain,[eval,['interpret-args',_227666,_227672,_227678,_227684,_227690]],_227696,[eval,['return-on-error',_227696,[chain,['cons-atom',_227756,_227696],_227768,[return,_227768]]]]]],['_ret'=_227768,'_head'=_227756,'_reduced_tail'=_227696,'_space'=_227690,'_ret_type'=_227684,'_args_tail_types'=_227678,'_args_tail'=_227672,'_atom'=_227666],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1013,2),line_char(1015,69))). -user:metta_file_buffer(18,355001248,indexed(metta_defun,['interpret-args-tail',_228414,_228436,_228458,_228480,_228502,_228524]),[=,['interpret-args-tail',_228938,_228944,_228950,_228956,_228962,_228968],[function,[chain,[eval,['interpret-args',_228938,_228950,_228956,_228962,_228968]],_229052,[eval,['return-on-error',_229052,[chain,['cons-atom',_228944,_229052],_229124,[return,_229124]]]]]]],['_ret'=_229124,'_reduced_tail'=_229052,'_space'=_228968,'_ret_type'=_228962,'_args_tail_types'=_228956,'_args_tail'=_228950,'_head'=_228944,'_atom'=_228938],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1012,0),line_char(1015,70))). -user:metta_file_buffer(19,356001249,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1017,1),line_char(1017,3))). -user:metta_file_buffer(19,356001249,constant,'interpret-tuple',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1017,4),line_char(1017,19))). -user:metta_file_buffer(19,356001249,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1017,20),line_char(1017,38))). -user:metta_file_buffer(18,356001249,metta_other,[iz,'interpret-tuple','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1017,0),line_char(1017,39))). -user:metta_file_buffer(19,357001250,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1018,1),line_char(1018,2))). -user:metta_file_buffer(20,357001251,constant,'interpret-tuple',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1018,4),line_char(1018,19))). -user:metta_file_buffer(20,357001251,variable,_190214,['_atom'=_190214],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1018,20),line_char(1018,25))). -user:metta_file_buffer(20,357001251,variable,_191522,['_space'=_191522],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1018,26),line_char(1018,32))). -user:metta_file_buffer(19,357001251,indexed(metta_other,['interpret-tuple',_192362,_192384]),['interpret-tuple',_192436,_192442],['_space'=_192442,'_atom'=_192436],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1018,3),line_char(1018,33))). -user:metta_file_buffer(20,357001252,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1019,3),line_char(1019,11))). -user:metta_file_buffer(21,357001253,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1019,13),line_char(1019,21))). -user:metta_file_buffer(21,357001253,variable,_195030,['_atom'=_195030],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1019,22),line_char(1019,27))). -user:metta_file_buffer(21,357001254,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1019,28),line_char(1019,30))). -user:metta_file_buffer(22,357001255,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1020,5),line_char(1020,11))). -user:metta_file_buffer(22,357001255,variable,_197792,['_atom'=_197792],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1020,12),line_char(1020,17))). -user:metta_file_buffer(21,357001255,indexed(metta_other,[return,_198626]),[return,_198678],['_atom'=_198678],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1020,4),line_char(1020,18))). -user:metta_file_buffer(22,357001256,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1021,5),line_char(1021,9))). -user:metta_file_buffer(23,357001257,constant,'if-decons',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1021,11),line_char(1021,20))). -user:metta_file_buffer(23,357001257,variable,_201228,['_atom'=_201228],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1021,21),line_char(1021,26))). -user:metta_file_buffer(23,357001257,variable,_202512,['_head'=_202512],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1021,27),line_char(1021,32))). -user:metta_file_buffer(23,357001257,variable,_203796,['_tail'=_203796],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1021,33),line_char(1021,38))). -user:metta_file_buffer(24,357001258,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1022,7),line_char(1022,12))). -user:metta_file_buffer(25,357001259,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1022,14),line_char(1022,18))). -user:metta_file_buffer(26,357001260,constant,interpret,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1022,20),line_char(1022,29))). -user:metta_file_buffer(26,357001260,variable,_207534,['_head'=_207534],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1022,30),line_char(1022,35))). -user:metta_file_buffer(26,357001260,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1022,36),line_char(1022,47))). -user:metta_file_buffer(26,357001260,variable,_209608,['_space'=_209608],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1022,48),line_char(1022,54))). -user:metta_file_buffer(25,357001260,indexed(metta_other,[interpret,_210454,'%Undefined%',_210484]),[interpret,_210536,'%Undefined%',_210548],['_space'=_210548,'_head'=_210536],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1022,19),line_char(1022,55))). -user:metta_file_buffer(24,357001260,indexed(metta_other,[eval,[interpret,_211098,'%Undefined%',_211128]]),[eval,[interpret,_211192,'%Undefined%',_211204]],['_space'=_211204,'_head'=_211192],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1022,13),line_char(1022,56))). -user:metta_file_buffer(24,357001260,variable,_212204,['_rhead'=_212204],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1022,57),line_char(1022,63))). -user:metta_file_buffer(25,357001261,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1023,9),line_char(1023,13))). -user:metta_file_buffer(26,357001262,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1023,15),line_char(1023,23))). -user:metta_file_buffer(26,357001262,variable,_215080,['_rhead'=_215080],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1023,24),line_char(1023,30))). -user:metta_file_buffer(26,357001262,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1023,31),line_char(1023,36))). -user:metta_file_buffer(27,357001263,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1023,38),line_char(1023,44))). -user:metta_file_buffer(27,357001263,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1023,45),line_char(1023,50))). -user:metta_file_buffer(26,357001263,metta_other,[return,'Empty'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1023,37),line_char(1023,51))). -user:metta_file_buffer(27,357001264,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1024,11),line_char(1024,16))). -user:metta_file_buffer(28,357001265,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1024,18),line_char(1024,22))). -user:metta_file_buffer(29,357001266,constant,'interpret-tuple',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1024,24),line_char(1024,39))). -user:metta_file_buffer(29,357001266,variable,_221372,['_tail'=_221372],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1024,40),line_char(1024,45))). -user:metta_file_buffer(29,357001266,variable,_222680,['_space'=_222680],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1024,46),line_char(1024,52))). -user:metta_file_buffer(28,357001266,indexed(metta_other,['interpret-tuple',_223520,_223542]),['interpret-tuple',_223594,_223600],['_space'=_223600,'_tail'=_223594],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1024,23),line_char(1024,53))). -user:metta_file_buffer(27,357001266,indexed(metta_other,[eval,['interpret-tuple',_224150,_224172]]),[eval,['interpret-tuple',_224236,_224242]],['_space'=_224242,'_tail'=_224236],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1024,17),line_char(1024,54))). -user:metta_file_buffer(27,357001266,variable,_225242,['_rtail'=_225242],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1024,55),line_char(1024,61))). -user:metta_file_buffer(28,357001267,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1025,13),line_char(1025,17))). -user:metta_file_buffer(29,357001268,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1025,19),line_char(1025,27))). -user:metta_file_buffer(29,357001268,variable,_228126,['_rtail'=_228126],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1025,28),line_char(1025,34))). -user:metta_file_buffer(29,357001268,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1025,35),line_char(1025,40))). -user:metta_file_buffer(30,357001269,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1025,42),line_char(1025,48))). -user:metta_file_buffer(30,357001269,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1025,49),line_char(1025,54))). -user:metta_file_buffer(29,357001269,metta_other,[return,'Empty'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1025,41),line_char(1025,55))). -user:metta_file_buffer(30,357001270,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1026,15),line_char(1026,20))). -user:metta_file_buffer(31,357001271,constant,'cons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1026,22),line_char(1026,31))). -user:metta_file_buffer(31,357001271,variable,_233588,['_rhead'=_233588],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1026,32),line_char(1026,38))). -user:metta_file_buffer(31,357001271,variable,_234896,['_rtail'=_234896],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1026,39),line_char(1026,45))). -user:metta_file_buffer(30,357001271,indexed(metta_other,['cons-atom',_235736,_235758]),['cons-atom',_235810,_235816],['_rtail'=_235816,'_rhead'=_235810],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1026,21),line_char(1026,46))). -user:metta_file_buffer(30,357001271,variable,_236784,['_ret'=_236784],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1026,47),line_char(1026,51))). -user:metta_file_buffer(31,357001272,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1026,53),line_char(1026,59))). -user:metta_file_buffer(31,357001272,variable,_238874,['_ret'=_238874],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1026,60),line_char(1026,64))). -user:metta_file_buffer(30,357001272,indexed(metta_other,[return,_239708]),[return,_239760],['_ret'=_239760],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1026,52),line_char(1026,65))). -user:metta_file_buffer(29,357001272,indexed(metta_other,[chain,['cons-atom',_240310,_240332],_240354,[return,_240354]]),[chain,['cons-atom',_240452,_240458],_240464,[return,_240464]],['_ret'=_240464,'_rtail'=_240458,'_rhead'=_240452],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1026,14),line_char(1026,66))). -user:metta_file_buffer(28,357001272,indexed(metta_other,['if-equal',_241048,'Empty',[return,'Empty'],[chain,['cons-atom',_241134,_241048],_241174,[return,_241174]]]),['if-equal',_241260,'Empty',[return,'Empty'],[chain,['cons-atom',_241302,_241260],_241314,[return,_241314]]],['_ret'=_241314,'_rhead'=_241302,'_rtail'=_241260],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1025,18),line_char(1026,68))). -user:metta_file_buffer(27,357001272,indexed(metta_other,[eval,['if-equal',_241894,'Empty',[return,'Empty'],[chain,['cons-atom',_241980,_241894],_242020,[return,_242020]]]]),[eval,['if-equal',_242118,'Empty',[return,'Empty'],[chain,['cons-atom',_242160,_242118],_242172,[return,_242172]]]],['_ret'=_242172,'_rhead'=_242160,'_rtail'=_242118],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1025,12),line_char(1026,69))). -user:metta_file_buffer(26,357001272,indexed(metta_other,[chain,[eval,['interpret-tuple',_242780,_242802]],_242824,[eval,['if-equal',_242824,'Empty',[return,'Empty'],[chain,['cons-atom',_242960,_242824],_243000,[return,_243000]]]]]),[chain,[eval,['interpret-tuple',_243110,_243116]],_243122,[eval,['if-equal',_243122,'Empty',[return,'Empty'],[chain,['cons-atom',_243194,_243122],_243206,[return,_243206]]]]],['_ret'=_243206,'_rhead'=_243194,'_rtail'=_243122,'_space'=_243116,'_tail'=_243110],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1024,10),line_char(1026,70))). -user:metta_file_buffer(25,357001272,indexed(metta_other,['if-equal',_243812,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_243914,_243936]],_243958,[eval,['if-equal',_243958,'Empty',[return,'Empty'],[chain,['cons-atom',_243812,_243958],_244130,[return,_244130]]]]]]),['if-equal',_244216,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_244270,_244276]],_244282,[eval,['if-equal',_244282,'Empty',[return,'Empty'],[chain,['cons-atom',_244216,_244282],_244366,[return,_244366]]]]]],['_ret'=_244366,'_rtail'=_244282,'_space'=_244276,'_tail'=_244270,'_rhead'=_244216],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1023,14),line_char(1026,71))). -user:metta_file_buffer(24,357001272,indexed(metta_other,[eval,['if-equal',_244970,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_245072,_245094]],_245116,[eval,['if-equal',_245116,'Empty',[return,'Empty'],[chain,['cons-atom',_244970,_245116],_245288,[return,_245288]]]]]]]),[eval,['if-equal',_245386,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_245440,_245446]],_245452,[eval,['if-equal',_245452,'Empty',[return,'Empty'],[chain,['cons-atom',_245386,_245452],_245536,[return,_245536]]]]]]],['_ret'=_245536,'_rtail'=_245452,'_space'=_245446,'_tail'=_245440,'_rhead'=_245386],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1023,8),line_char(1026,72))). -user:metta_file_buffer(23,357001272,indexed(metta_other,[chain,[eval,[interpret,_246168,'%Undefined%',_246198]],_246220,[eval,['if-equal',_246220,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_246372,_246198]],_246412,[eval,['if-equal',_246412,'Empty',[return,'Empty'],[chain,['cons-atom',_246220,_246412],_246584,[return,_246584]]]]]]]]),[chain,[eval,[interpret,_246694,'%Undefined%',_246706]],_246712,[eval,['if-equal',_246712,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_246796,_246706]],_246808,[eval,['if-equal',_246808,'Empty',[return,'Empty'],[chain,['cons-atom',_246712,_246808],_246892,[return,_246892]]]]]]]],['_ret'=_246892,'_rtail'=_246808,'_tail'=_246796,'_rhead'=_246712,'_space'=_246706,'_head'=_246694],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1022,6),line_char(1026,73))). -user:metta_file_buffer(24,357001273,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1027,7),line_char(1027,13))). -user:metta_file_buffer(25,357001274,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1027,15),line_char(1027,20))). -user:metta_file_buffer(26,357001275,constant,'interpret-tuple',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1027,22),line_char(1027,37))). -user:metta_file_buffer(26,357001275,variable,_250340,['_atom'=_250340],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1027,38),line_char(1027,43))). -user:metta_file_buffer(26,357001275,variable,_251648,['_space'=_251648],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1027,44),line_char(1027,50))). -user:metta_file_buffer(25,357001275,indexed(metta_other,['interpret-tuple',_252488,_252510]),['interpret-tuple',_252562,_252568],['_space'=_252568,'_atom'=_252562],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1027,21),line_char(1027,51))). -user:metta_file_buffer(25,357001275,string,"Non-empty expression atom is expected as an argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1027,52),line_char(1027,106))). -user:metta_file_buffer(24,357001275,indexed(metta_other,['Error',['interpret-tuple',_254212,_254234],"Non-empty expression atom is expected as an argument"]),['Error',['interpret-tuple',_254306,_254312],"Non-empty expression atom is expected as an argument"],['_space'=_254312,'_atom'=_254306],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1027,14),line_char(1027,107))). -user:metta_file_buffer(23,357001275,indexed(metta_other,[return,['Error',['interpret-tuple',_254878,_254900],"Non-empty expression atom is expected as an argument"]]),[return,['Error',['interpret-tuple',_254984,_254990],"Non-empty expression atom is expected as an argument"]],['_space'=_254990,'_atom'=_254984],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1027,6),line_char(1027,108))). -user:metta_file_buffer(22,357001275,indexed(metta_other,['if-decons',_255550,_255572,_255594,[chain,[eval,[interpret,_255572,'%Undefined%',_255690]],_255712,[eval,['if-equal',_255712,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_255594,_255690]],_255900,[eval,['if-equal',_255900,'Empty',[return,'Empty'],[chain,['cons-atom',_255712,_255900],_256072,[return,_256072]]]]]]]],[return,['Error',['interpret-tuple',_255550,_255690],"Non-empty expression atom is expected as an argument"]]]),['if-decons',_256250,_256256,_256262,[chain,[eval,[interpret,_256256,'%Undefined%',_256316]],_256322,[eval,['if-equal',_256322,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_256262,_256316]],_256418,[eval,['if-equal',_256418,'Empty',[return,'Empty'],[chain,['cons-atom',_256322,_256418],_256502,[return,_256502]]]]]]]],[return,['Error',['interpret-tuple',_256250,_256316],"Non-empty expression atom is expected as an argument"]]],['_ret'=_256502,'_rtail'=_256418,'_rhead'=_256322,'_space'=_256316,'_tail'=_256262,'_head'=_256256,'_atom'=_256250],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1021,10),line_char(1027,110))). -user:metta_file_buffer(21,357001275,indexed(metta_other,[eval,['if-decons',_257178,_257200,_257222,[chain,[eval,[interpret,_257200,'%Undefined%',_257318]],_257340,[eval,['if-equal',_257340,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_257222,_257318]],_257528,[eval,['if-equal',_257528,'Empty',[return,'Empty'],[chain,['cons-atom',_257340,_257528],_257700,[return,_257700]]]]]]]],[return,['Error',['interpret-tuple',_257178,_257318],"Non-empty expression atom is expected as an argument"]]]]),[eval,['if-decons',_257890,_257896,_257902,[chain,[eval,[interpret,_257896,'%Undefined%',_257956]],_257962,[eval,['if-equal',_257962,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_257902,_257956]],_258058,[eval,['if-equal',_258058,'Empty',[return,'Empty'],[chain,['cons-atom',_257962,_258058],_258142,[return,_258142]]]]]]]],[return,['Error',['interpret-tuple',_257890,_257956],"Non-empty expression atom is expected as an argument"]]]],['_ret'=_258142,'_rtail'=_258058,'_rhead'=_257962,'_space'=_257956,'_tail'=_257902,'_head'=_257896,'_atom'=_257890],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1021,4),line_char(1027,111))). -user:metta_file_buffer(20,357001275,indexed(metta_other,['if-unify',_258820,[],[return,_258820],[eval,['if-decons',_258820,_258934,_258956,[chain,[eval,[interpret,_258934,'%Undefined%',_259052]],_259074,[eval,['if-equal',_259074,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_258956,_259052]],_259262,[eval,['if-equal',_259262,'Empty',[return,'Empty'],[chain,['cons-atom',_259074,_259262],_259434,[return,_259434]]]]]]]],[return,['Error',['interpret-tuple',_258820,_259052],"Non-empty expression atom is expected as an argument"]]]]]),['if-unify',_259612,[],[return,_259612],[eval,['if-decons',_259612,_259672,_259678,[chain,[eval,[interpret,_259672,'%Undefined%',_259732]],_259738,[eval,['if-equal',_259738,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_259678,_259732]],_259834,[eval,['if-equal',_259834,'Empty',[return,'Empty'],[chain,['cons-atom',_259738,_259834],_259918,[return,_259918]]]]]]]],[return,['Error',['interpret-tuple',_259612,_259732],"Non-empty expression atom is expected as an argument"]]]]],['_ret'=_259918,'_rtail'=_259834,'_rhead'=_259738,'_space'=_259732,'_tail'=_259678,'_head'=_259672,'_atom'=_259612],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1019,12),line_char(1027,112))). -user:metta_file_buffer(19,357001275,indexed(metta_other,[function,['if-unify',_260594,[],[return,_260594],[eval,['if-decons',_260594,_260708,_260730,[chain,[eval,[interpret,_260708,'%Undefined%',_260826]],_260848,[eval,['if-equal',_260848,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_260730,_260826]],_261036,[eval,['if-equal',_261036,'Empty',[return,'Empty'],[chain,['cons-atom',_260848,_261036],_261208,[return,_261208]]]]]]]],[return,['Error',['interpret-tuple',_260594,_260826],"Non-empty expression atom is expected as an argument"]]]]]]),[function,['if-unify',_261398,[],[return,_261398],[eval,['if-decons',_261398,_261458,_261464,[chain,[eval,[interpret,_261458,'%Undefined%',_261518]],_261524,[eval,['if-equal',_261524,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_261464,_261518]],_261620,[eval,['if-equal',_261620,'Empty',[return,'Empty'],[chain,['cons-atom',_261524,_261620],_261704,[return,_261704]]]]]]]],[return,['Error',['interpret-tuple',_261398,_261518],"Non-empty expression atom is expected as an argument"]]]]]],['_ret'=_261704,'_rtail'=_261620,'_rhead'=_261524,'_space'=_261518,'_tail'=_261464,'_head'=_261458,'_atom'=_261398],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1019,2),line_char(1027,113))). -user:metta_file_buffer(18,357001275,indexed(metta_defun,['interpret-tuple',_262386,_262408]),[=,['interpret-tuple',_263258,_263264],[function,['if-unify',_263258,[],[return,_263258],[eval,['if-decons',_263258,_263354,_263360,[chain,[eval,[interpret,_263354,'%Undefined%',_263264]],_263420,[eval,['if-equal',_263420,'Empty',[return,'Empty'],[chain,[eval,['interpret-tuple',_263360,_263264]],_263516,[eval,['if-equal',_263516,'Empty',[return,'Empty'],[chain,['cons-atom',_263420,_263516],_263600,[return,_263600]]]]]]]],[return,['Error',['interpret-tuple',_263258,_263264],"Non-empty expression atom is expected as an argument"]]]]]]],['_ret'=_263600,'_rtail'=_263516,'_rhead'=_263420,'_tail'=_263360,'_head'=_263354,'_space'=_263264,'_atom'=_263258],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1018,0),line_char(1027,114))). -user:metta_file_buffer(19,358001276,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1029,1),line_char(1029,3))). -user:metta_file_buffer(19,358001276,constant,'metta-call',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1029,4),line_char(1029,14))). -user:metta_file_buffer(19,358001276,constant,'MinimalMeTTaHelper',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1029,15),line_char(1029,33))). -user:metta_file_buffer(18,358001276,metta_other,[iz,'metta-call','MinimalMeTTaHelper'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1029,0),line_char(1029,34))). -user:metta_file_buffer(19,359001277,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1030,1),line_char(1030,2))). -user:metta_file_buffer(20,359001278,constant,'metta-call',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1030,4),line_char(1030,14))). -user:metta_file_buffer(20,359001278,variable,_210782,['_atom'=_210782],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1030,15),line_char(1030,20))). -user:metta_file_buffer(20,359001278,variable,_212066,['_type'=_212066],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1030,21),line_char(1030,26))). -user:metta_file_buffer(20,359001278,variable,_213374,['_space'=_213374],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1030,27),line_char(1030,33))). -user:metta_file_buffer(19,359001278,indexed(metta_other,['metta-call',_214220,_214242,_214264]),['metta-call',_214316,_214322,_214328],['_space'=_214328,'_type'=_214322,'_atom'=_214316],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1030,3),line_char(1030,34))). -user:metta_file_buffer(20,359001279,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1031,3),line_char(1031,11))). -user:metta_file_buffer(21,359001280,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1031,13),line_char(1031,17))). -user:metta_file_buffer(22,359001281,constant,'if-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1031,19),line_char(1031,27))). -user:metta_file_buffer(22,359001281,variable,_217722,['_atom'=_217722],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1031,28),line_char(1031,33))). -user:metta_file_buffer(23,359001282,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1031,35),line_char(1031,41))). -user:metta_file_buffer(23,359001282,variable,_219828,['_atom'=_219828],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1031,42),line_char(1031,47))). -user:metta_file_buffer(22,359001282,indexed(metta_other,[return,_220662]),[return,_220714],['_atom'=_220714],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1031,34),line_char(1031,48))). -user:metta_file_buffer(23,359001283,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1032,5),line_char(1032,10))). -user:metta_file_buffer(24,359001284,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1032,12),line_char(1032,16))). -user:metta_file_buffer(24,359001284,variable,_223300,['_atom'=_223300],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1032,17),line_char(1032,22))). -user:metta_file_buffer(23,359001284,indexed(metta_other,[eval,_224134]),[eval,_224186],['_atom'=_224186],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1032,11),line_char(1032,23))). -user:metta_file_buffer(23,359001284,variable,_225206,['_result'=_225206],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1032,24),line_char(1032,31))). -user:metta_file_buffer(24,359001285,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1033,7),line_char(1033,11))). -user:metta_file_buffer(25,359001286,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1033,13),line_char(1033,21))). -user:metta_file_buffer(25,359001286,variable,_228110,['_result'=_228110],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1033,22),line_char(1033,29))). -user:metta_file_buffer(25,359001286,constant,'NotReducible',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1033,30),line_char(1033,42))). -user:metta_file_buffer(26,359001287,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1033,44),line_char(1033,50))). -user:metta_file_buffer(26,359001287,variable,_230884,['_atom'=_230884],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1033,51),line_char(1033,56))). -user:metta_file_buffer(25,359001287,indexed(metta_other,[return,_231718]),[return,_231770],['_atom'=_231770],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1033,43),line_char(1033,57))). -user:metta_file_buffer(26,359001288,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1034,9),line_char(1034,13))). -user:metta_file_buffer(27,359001289,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1034,15),line_char(1034,23))). -user:metta_file_buffer(27,359001289,variable,_234366,['_result'=_234366],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1034,24),line_char(1034,31))). -user:metta_file_buffer(27,359001289,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1034,32),line_char(1034,37))). -user:metta_file_buffer(28,359001290,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1034,39),line_char(1034,45))). -user:metta_file_buffer(28,359001290,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1034,46),line_char(1034,51))). -user:metta_file_buffer(27,359001290,metta_other,[return,'Empty'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1034,38),line_char(1034,52))). -user:metta_file_buffer(28,359001291,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1035,11),line_char(1035,15))). -user:metta_file_buffer(29,359001292,constant,'if-error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1035,17),line_char(1035,25))). -user:metta_file_buffer(29,359001292,variable,_239832,['_result'=_239832],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1035,26),line_char(1035,33))). -user:metta_file_buffer(30,359001293,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1035,35),line_char(1035,41))). -user:metta_file_buffer(30,359001293,variable,_241986,['_result'=_241986],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1035,42),line_char(1035,49))). -user:metta_file_buffer(29,359001293,indexed(metta_other,[return,_242820]),[return,_242872],['_result'=_242872],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1035,34),line_char(1035,50))). -user:metta_file_buffer(30,359001294,constant,chain,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,13),line_char(1036,18))). -user:metta_file_buffer(31,359001295,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,20),line_char(1036,24))). -user:metta_file_buffer(32,359001296,constant,interpret,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,26),line_char(1036,35))). -user:metta_file_buffer(32,359001296,variable,_246358,['_result'=_246358],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,36),line_char(1036,43))). -user:metta_file_buffer(32,359001296,variable,_247642,['_type'=_247642],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,44),line_char(1036,49))). -user:metta_file_buffer(32,359001296,variable,_248950,['_space'=_248950],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,50),line_char(1036,56))). -user:metta_file_buffer(31,359001296,indexed(metta_other,[interpret,_249796,_249818,_249840]),[interpret,_249892,_249898,_249904],['_space'=_249904,'_type'=_249898,'_result'=_249892],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,25),line_char(1036,57))). -user:metta_file_buffer(30,359001296,indexed(metta_other,[eval,[interpret,_250466,_250488,_250510]]),[eval,[interpret,_250574,_250580,_250586]],['_space'=_250586,'_type'=_250580,'_result'=_250574],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,19),line_char(1036,58))). -user:metta_file_buffer(30,359001296,variable,_251566,['_ret'=_251566],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,59),line_char(1036,63))). -user:metta_file_buffer(31,359001297,constant,return,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,65),line_char(1036,71))). -user:metta_file_buffer(31,359001297,variable,_253656,['_ret'=_253656],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,72),line_char(1036,76))). -user:metta_file_buffer(30,359001297,indexed(metta_other,[return,_254490]),[return,_254542],['_ret'=_254542],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,64),line_char(1036,77))). -user:metta_file_buffer(29,359001297,indexed(metta_other,[chain,[eval,[interpret,_255108,_255130,_255152]],_255174,[return,_255174]]),[chain,[eval,[interpret,_255284,_255290,_255296]],_255302,[return,_255302]],['_ret'=_255302,'_space'=_255296,'_type'=_255290,'_result'=_255284],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1036,12),line_char(1036,78))). -user:metta_file_buffer(28,359001297,indexed(metta_other,['if-error',_255892,[return,_255892],[chain,[eval,[interpret,_255892,_256014,_256036]],_256058,[return,_256058]]]),['if-error',_256144,[return,_256144],[chain,[eval,[interpret,_256144,_256210,_256216]],_256222,[return,_256222]]],['_ret'=_256222,'_space'=_256216,'_type'=_256210,'_result'=_256144],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1035,16),line_char(1036,80))). -user:metta_file_buffer(27,359001297,indexed(metta_other,[eval,['if-error',_256814,[return,_256814],[chain,[eval,[interpret,_256814,_256936,_256958]],_256980,[return,_256980]]]]),[eval,['if-error',_257078,[return,_257078],[chain,[eval,[interpret,_257078,_257144,_257150]],_257156,[return,_257156]]]],['_ret'=_257156,'_space'=_257150,'_type'=_257144,'_result'=_257078],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1035,10),line_char(1036,81))). -user:metta_file_buffer(26,359001297,indexed(metta_other,['if-equal',_257750,'Empty',[return,'Empty'],[eval,['if-error',_257750,[return,_257750],[chain,[eval,[interpret,_257750,_257954,_257976]],_257998,[return,_257998]]]]]),['if-equal',_258084,'Empty',[return,'Empty'],[eval,['if-error',_258084,[return,_258084],[chain,[eval,[interpret,_258084,_258192,_258198]],_258204,[return,_258204]]]]],['_ret'=_258204,'_space'=_258198,'_type'=_258192,'_result'=_258084],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1034,14),line_char(1036,82))). -user:metta_file_buffer(25,359001297,indexed(metta_other,[eval,['if-equal',_258796,'Empty',[return,'Empty'],[eval,['if-error',_258796,[return,_258796],[chain,[eval,[interpret,_258796,_259000,_259022]],_259044,[return,_259044]]]]]]),[eval,['if-equal',_259142,'Empty',[return,'Empty'],[eval,['if-error',_259142,[return,_259142],[chain,[eval,[interpret,_259142,_259250,_259256]],_259262,[return,_259262]]]]]],['_ret'=_259262,'_space'=_259256,'_type'=_259250,'_result'=_259142],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1034,8),line_char(1036,83))). -user:metta_file_buffer(24,359001297,indexed(metta_other,['if-equal',_259856,'NotReducible',[return,_259902],[eval,['if-equal',_259856,'Empty',[return,'Empty'],[eval,['if-error',_259856,[return,_259856],[chain,[eval,[interpret,_259856,_260156,_260178]],_260200,[return,_260200]]]]]]]),['if-equal',_260286,'NotReducible',[return,_260310],[eval,['if-equal',_260286,'Empty',[return,'Empty'],[eval,['if-error',_260286,[return,_260286],[chain,[eval,[interpret,_260286,_260448,_260454]],_260460,[return,_260460]]]]]]],['_ret'=_260460,'_space'=_260454,'_type'=_260448,'_atom'=_260310,'_result'=_260286],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1033,12),line_char(1036,84))). -user:metta_file_buffer(23,359001297,indexed(metta_other,[eval,['if-equal',_261064,'NotReducible',[return,_261110],[eval,['if-equal',_261064,'Empty',[return,'Empty'],[eval,['if-error',_261064,[return,_261064],[chain,[eval,[interpret,_261064,_261364,_261386]],_261408,[return,_261408]]]]]]]]),[eval,['if-equal',_261506,'NotReducible',[return,_261530],[eval,['if-equal',_261506,'Empty',[return,'Empty'],[eval,['if-error',_261506,[return,_261506],[chain,[eval,[interpret,_261506,_261668,_261674]],_261680,[return,_261680]]]]]]]],['_ret'=_261680,'_space'=_261674,'_type'=_261668,'_atom'=_261530,'_result'=_261506],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1033,6),line_char(1036,85))). -user:metta_file_buffer(22,359001297,indexed(metta_other,[chain,[eval,_262296],_262318,[eval,['if-equal',_262318,'NotReducible',[return,_262296],[eval,['if-equal',_262318,'Empty',[return,'Empty'],[eval,['if-error',_262318,[return,_262318],[chain,[eval,[interpret,_262318,_262664,_262686]],_262708,[return,_262708]]]]]]]]]),[chain,[eval,_262806],_262812,[eval,['if-equal',_262812,'NotReducible',[return,_262806],[eval,['if-equal',_262812,'Empty',[return,'Empty'],[eval,['if-error',_262812,[return,_262812],[chain,[eval,[interpret,_262812,_263004,_263010]],_263016,[return,_263016]]]]]]]]],['_ret'=_263016,'_space'=_263010,'_type'=_263004,'_result'=_262812,'_atom'=_262806],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1032,4),line_char(1036,86))). -user:metta_file_buffer(21,359001297,indexed(metta_other,['if-error',_263616,[return,_263616],[chain,[eval,_263616],_263722,[eval,['if-equal',_263722,'NotReducible',[return,_263616],[eval,['if-equal',_263722,'Empty',[return,'Empty'],[eval,['if-error',_263722,[return,_263722],[chain,[eval,[interpret,_263722,_264068,_264090]],_264112,[return,_264112]]]]]]]]]]),['if-error',_264198,[return,_264198],[chain,[eval,_264198],_264252,[eval,['if-equal',_264252,'NotReducible',[return,_264198],[eval,['if-equal',_264252,'Empty',[return,'Empty'],[eval,['if-error',_264252,[return,_264252],[chain,[eval,[interpret,_264252,_264444,_264450]],_264456,[return,_264456]]]]]]]]]],['_ret'=_264456,'_space'=_264450,'_type'=_264444,'_result'=_264252,'_atom'=_264198],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1031,18),line_char(1036,87))). -user:metta_file_buffer(20,359001297,indexed(metta_other,[eval,['if-error',_265060,[return,_265060],[chain,[eval,_265060],_265166,[eval,['if-equal',_265166,'NotReducible',[return,_265060],[eval,['if-equal',_265166,'Empty',[return,'Empty'],[eval,['if-error',_265166,[return,_265166],[chain,[eval,[interpret,_265166,_265512,_265534]],_265556,[return,_265556]]]]]]]]]]]),[eval,['if-error',_265654,[return,_265654],[chain,[eval,_265654],_265708,[eval,['if-equal',_265708,'NotReducible',[return,_265654],[eval,['if-equal',_265708,'Empty',[return,'Empty'],[eval,['if-error',_265708,[return,_265708],[chain,[eval,[interpret,_265708,_265900,_265906]],_265912,[return,_265912]]]]]]]]]]],['_ret'=_265912,'_space'=_265906,'_type'=_265900,'_result'=_265708,'_atom'=_265654],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1031,12),line_char(1036,88))). -user:metta_file_buffer(19,359001297,indexed(metta_other,[function,[eval,['if-error',_266532,[return,_266532],[chain,[eval,_266532],_266638,[eval,['if-equal',_266638,'NotReducible',[return,_266532],[eval,['if-equal',_266638,'Empty',[return,'Empty'],[eval,['if-error',_266638,[return,_266638],[chain,[eval,[interpret,_266638,_266984,_267006]],_267028,[return,_267028]]]]]]]]]]]]),[function,[eval,['if-error',_267138,[return,_267138],[chain,[eval,_267138],_267192,[eval,['if-equal',_267192,'NotReducible',[return,_267138],[eval,['if-equal',_267192,'Empty',[return,'Empty'],[eval,['if-error',_267192,[return,_267192],[chain,[eval,[interpret,_267192,_267384,_267390]],_267396,[return,_267396]]]]]]]]]]]],['_ret'=_267396,'_space'=_267390,'_type'=_267384,'_result'=_267192,'_atom'=_267138],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1031,2),line_char(1036,89))). -user:metta_file_buffer(18,359001297,indexed(metta_defun,['metta-call',_268006,_268028,_268050]),[=,['metta-call',_268702,_268708,_268714],[function,[eval,['if-error',_268702,[return,_268702],[chain,[eval,_268702],_268810,[eval,['if-equal',_268810,'NotReducible',[return,_268702],[eval,['if-equal',_268810,'Empty',[return,'Empty'],[eval,['if-error',_268810,[return,_268810],[chain,[eval,[interpret,_268810,_268708,_268714]],_269014,[return,_269014]]]]]]]]]]]]],['_ret'=_269014,'_result'=_268810,'_space'=_268714,'_type'=_268708,'_atom'=_268702],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1030,0),line_char(1036,90))). -user:metta_file_buffer(18,360001297,indexed(metta_comment,";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"),'$COMMENT'(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",1038,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1038,0),line_char(1038,37))). -user:metta_file_buffer(18,360001297,indexed(metta_comment,"; Standard library written in MeTTa ;"),'$COMMENT'("; Standard library written in MeTTa ;",1039,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1039,0),line_char(1039,37))). -user:metta_file_buffer(18,360001297,indexed(metta_comment,";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"),'$COMMENT'(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",1040,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1040,0),line_char(1040,37))). -user:metta_file_buffer(18,360001297,indexed(metta_comment,"; TODO: Type is used here, but there is no definition for the -> type"),'$COMMENT'("; TODO: Type is used here, but there is no definition for the -> type",1042,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1042,0),line_char(1042,69))). -user:metta_file_buffer(18,360001297,indexed(metta_comment,"; constructor for instance, thus in practice it matches because -> has"),'$COMMENT'("; constructor for instance, thus in practice it matches because -> has",1043,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1043,0),line_char(1043,70))). -user:metta_file_buffer(18,360001297,indexed(metta_comment,"; %Undefined% type. We need to assign proper type to -> and other type"),'$COMMENT'("; %Undefined% type. We need to assign proper type to -> and other type",1044,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1044,0),line_char(1044,70))). -user:metta_file_buffer(18,360001297,indexed(metta_comment,"; constructors but it is not possible until we support vararg types."),'$COMMENT'("; constructors but it is not possible until we support vararg types.",1045,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1045,0),line_char(1045,68))). -user:metta_file_buffer(19,360001298,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1046,1),line_char(1046,3))). -user:metta_file_buffer(19,360001298,constant,'is-function-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1046,4),line_char(1046,20))). -user:metta_file_buffer(19,360001298,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1046,21),line_char(1046,26))). -user:metta_file_buffer(18,360001298,metta_other,[iz,'is-function-type','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1046,0),line_char(1046,27))). -user:metta_file_buffer(18,361001298,indexed(metta_comment,"; or Helper?"),'$COMMENT'("; or Helper?",1046,28),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1046,28),line_char(1046,40))). -user:metta_file_buffer(19,361001299,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1047,1),line_char(1047,5))). -user:metta_file_buffer(19,361001299,constant,'is-function-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1047,6),line_char(1047,22))). -user:metta_file_buffer(20,361001300,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1048,3),line_char(1048,8))). -user:metta_file_buffer(20,361001300,string,"Function checks if input type is a function type",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1048,9),line_char(1048,59))). -user:metta_file_buffer(19,361001300,metta_other,['@desc',"Function checks if input type is a function type"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1048,2),line_char(1048,60))). -user:metta_file_buffer(20,361001301,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1049,3),line_char(1049,10))). -user:metta_file_buffer(22,361001303,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1050,5),line_char(1050,11))). -user:metta_file_buffer(22,361001303,string,"Type notation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1050,12),line_char(1050,27))). -user:metta_file_buffer(21,361001303,metta_other,['@param',"Type notation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1050,4),line_char(1050,28))). -user:metta_file_buffer(20,361001303,array,[['@param',"Type notation"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1049,11),line_char(1050,29))). -user:metta_file_buffer(19,361001303,metta_other,['@params',[['@param',"Type notation"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1049,2),line_char(1050,30))). -user:metta_file_buffer(20,361001304,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1051,3),line_char(1051,10))). -user:metta_file_buffer(20,361001304,string,"True if input type notation is a function type, False - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1051,11),line_char(1051,78))). -user:metta_file_buffer(19,361001304,metta_other,['@return',"True if input type notation is a function type, False - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1051,2),line_char(1051,79))). -user:metta_file_buffer(18,361001304,metta_other,['@doc','is-function-type',['@desc',"Function checks if input type is a function type"],['@params',[['@param',"Type notation"]]],['@return',"True if input type notation is a function type, False - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1047,0),line_char(1051,80))). -user:metta_file_buffer(19,362001305,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1052,1),line_char(1052,2))). -user:metta_file_buffer(19,362001305,constant,'is-function-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1052,3),line_char(1052,19))). -user:metta_file_buffer(20,362001306,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1052,21),line_char(1052,23))). -user:metta_file_buffer(20,362001306,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1052,24),line_char(1052,28))). -user:metta_file_buffer(20,362001306,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1052,29),line_char(1052,33))). -user:metta_file_buffer(19,362001306,metta_other,[->,'Type','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1052,20),line_char(1052,34))). -user:metta_file_buffer(18,362001306,metta_typedecl,[:,'is-function-type',[->,'Type','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1052,0),line_char(1052,35))). -user:metta_file_buffer(19,363001307,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1053,1),line_char(1053,2))). -user:metta_file_buffer(20,363001308,constant,'is-function-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1053,4),line_char(1053,20))). -user:metta_file_buffer(20,363001308,variable,_210850,['_type'=_210850],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1053,21),line_char(1053,26))). -user:metta_file_buffer(19,363001308,indexed(metta_other,['is-function-type',_211684]),['is-function-type',_211736],['_type'=_211736],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1053,3),line_char(1053,27))). -user:metta_file_buffer(20,363001309,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1054,3),line_char(1054,6))). -user:metta_file_buffer(20,363001309,variable,_213598,['_type_meta'=_213598],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1054,7),line_char(1054,17))). -user:metta_file_buffer(21,363001310,constant,'get-metatype',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1054,19),line_char(1054,31))). -user:metta_file_buffer(21,363001310,variable,_215696,['_type'=_215696],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1054,32),line_char(1054,37))). -user:metta_file_buffer(20,363001310,indexed(metta_other,['get-metatype',_216530]),['get-metatype',_216582],['_type'=_216582],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1054,18),line_char(1054,38))). -user:metta_file_buffer(21,363001311,constant,case,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1055,5),line_char(1055,9))). -user:metta_file_buffer(21,363001311,variable,_218458,['_type_meta'=_218458],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1055,10),line_char(1055,20))). -user:metta_file_buffer(23,363001313,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1056,7),line_char(1056,17))). -user:metta_file_buffer(24,363001314,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1057,9),line_char(1057,12))). -user:metta_file_buffer(24,363001314,variable,_221496,['_first'=_221496],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1057,13),line_char(1057,19))). -user:metta_file_buffer(25,363001315,constant,'car-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1057,21),line_char(1057,29))). -user:metta_file_buffer(25,363001315,variable,_223554,['_type'=_223554],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1057,30),line_char(1057,35))). -user:metta_file_buffer(24,363001315,indexed(metta_other,['car-atom',_224388]),['car-atom',_224440],['_type'=_224440],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1057,20),line_char(1057,36))). -user:metta_file_buffer(25,363001316,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1058,11),line_char(1058,13))). -user:metta_file_buffer(26,363001317,constant,==,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1058,15),line_char(1058,17))). -user:metta_file_buffer(26,363001317,variable,_226996,['_first'=_226996],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1058,18),line_char(1058,24))). -user:metta_file_buffer(26,363001317,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1058,25),line_char(1058,27))). -user:metta_file_buffer(25,363001317,indexed(metta_other,[==,_228480,->]),[==,_228540,->],['_first'=_228540],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1058,14),line_char(1058,28))). -user:metta_file_buffer(25,363001317,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1058,29),line_char(1058,33))). -user:metta_file_buffer(25,363001317,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1058,34),line_char(1058,39))). -user:metta_file_buffer(24,363001317,indexed(metta_other,[if,[==,_230284,->],'True','False']),[if,[==,_230372,->],'True','False'],['_first'=_230372],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1058,10),line_char(1058,40))). -user:metta_file_buffer(23,363001317,indexed(metta_other,[let,_230908,['car-atom',_230946],[if,[==,_230908,->],'True','False']]),[let,_231072,['car-atom',_231090],[if,[==,_231072,->],'True','False']],['_type'=_231090,'_first'=_231072],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1057,8),line_char(1058,42))). -user:metta_file_buffer(22,363001317,indexed(metta_other,['Expression',[let,_231670,['car-atom',_231708],[if,[==,_231670,->],'True','False']]]),['Expression',[let,_231846,['car-atom',_231864],[if,[==,_231846,->],'True','False']]],['_type'=_231864,'_first'=_231846],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1056,6),line_char(1058,43))). -user:metta_file_buffer(23,364001318,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1059,10),line_char(1059,15))). -user:metta_file_buffer(23,365001318,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1059,15),line_char(1059,16))). -user:metta_file_buffer(23,366001318,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1059,17),line_char(1059,18))). -user:metta_file_buffer(23,367001318,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1059,18),line_char(1059,19))). -user:metta_file_buffer(23,368001318,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1059,19),line_char(1059,20))). -user:metta_file_buffer(23,369001318,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1059,20),line_char(1059,21))). -user:metta_file_buffer(23,370001318,indexed(metta_comment,";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"),'$COMMENT'(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",1062,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1062,0),line_char(1062,36))). -user:metta_file_buffer(23,370001318,indexed(metta_comment,"; MeTTa interpreter implementation ;"),'$COMMENT'("; MeTTa interpreter implementation ;",1063,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1063,0),line_char(1063,36))). -user:metta_file_buffer(23,370001318,indexed(metta_comment,";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"),'$COMMENT'(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",1064,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1064,0),line_char(1064,36))). -user:metta_file_buffer(24,370001319,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1066,1),line_char(1066,3))). -user:metta_file_buffer(24,370001319,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1066,4),line_char(1066,6))). -user:metta_file_buffer(24,370001319,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1066,7),line_char(1066,12))). -user:metta_file_buffer(23,370001319,metta_other,[iz,if,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1066,0),line_char(1066,13))). -user:metta_file_buffer(24,371001320,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1067,1),line_char(1067,5))). -user:metta_file_buffer(24,371001320,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1067,6),line_char(1067,8))). -user:metta_file_buffer(25,371001321,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1068,3),line_char(1068,8))). -user:metta_file_buffer(25,371001321,string,"Replace itself by one of the arguments depending on condition.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1068,9),line_char(1068,73))). -user:metta_file_buffer(24,371001321,metta_other,['@desc',"Replace itself by one of the arguments depending on condition."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1068,2),line_char(1068,74))). -user:metta_file_buffer(25,371001322,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1069,3),line_char(1069,10))). -user:metta_file_buffer(27,371001324,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1070,5),line_char(1070,11))). -user:metta_file_buffer(27,371001324,string,"Boolean condition",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1070,12),line_char(1070,31))). -user:metta_file_buffer(26,371001324,metta_other,['@param',"Boolean condition"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1070,4),line_char(1070,32))). -user:metta_file_buffer(27,371001325,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1071,5),line_char(1071,11))). -user:metta_file_buffer(27,371001325,string,"Result when condition is True",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1071,12),line_char(1071,43))). -user:metta_file_buffer(26,371001325,metta_other,['@param',"Result when condition is True"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1071,4),line_char(1071,44))). -user:metta_file_buffer(27,371001326,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1072,5),line_char(1072,11))). -user:metta_file_buffer(27,371001326,string,"Result when condition is False",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1072,12),line_char(1072,44))). -user:metta_file_buffer(26,371001326,metta_other,['@param',"Result when condition is False"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1072,4),line_char(1072,45))). -user:metta_file_buffer(25,371001326,array,[['@param',"Boolean condition"],['@param',"Result when condition is True"],['@param',"Result when condition is False"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1069,11),line_char(1072,46))). -user:metta_file_buffer(24,371001326,metta_other,['@params',[['@param',"Boolean condition"],['@param',"Result when condition is True"],['@param',"Result when condition is False"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1069,2),line_char(1072,47))). -user:metta_file_buffer(25,371001327,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1073,3),line_char(1073,10))). -user:metta_file_buffer(25,371001327,string,"Second or third argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1073,11),line_char(1073,37))). -user:metta_file_buffer(24,371001327,metta_other,['@return',"Second or third argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1073,2),line_char(1073,38))). -user:metta_file_buffer(23,371001327,metta_other,['@doc',if,['@desc',"Replace itself by one of the arguments depending on condition."],['@params',[['@param',"Boolean condition"],['@param',"Result when condition is True"],['@param',"Result when condition is False"]]],['@return',"Second or third argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1067,0),line_char(1073,40))). -user:metta_file_buffer(24,372001328,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1074,1),line_char(1074,2))). -user:metta_file_buffer(24,372001328,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1074,3),line_char(1074,5))). -user:metta_file_buffer(25,372001329,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1074,7),line_char(1074,9))). -user:metta_file_buffer(25,372001329,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1074,10),line_char(1074,14))). -user:metta_file_buffer(25,372001329,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1074,15),line_char(1074,19))). -user:metta_file_buffer(25,372001329,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1074,20),line_char(1074,24))). -user:metta_file_buffer(25,372001329,variable,_214874,['_t'=_214874],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1074,25),line_char(1074,27))). -user:metta_file_buffer(24,372001329,indexed(metta_other,[->,'Bool','Atom','Atom',_215750]),[->,'Bool','Atom','Atom',_215820],['_t'=_215820],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1074,6),line_char(1074,28))). -user:metta_file_buffer(23,372001329,indexed(metta_typedecl,[:,if,[->,'Bool','Atom','Atom',_216396]]),[:,if,[->,'Bool','Atom','Atom',_216484]],['_t'=_216484],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1074,0),line_char(1074,29))). -user:metta_file_buffer(24,373001330,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1075,1),line_char(1075,5))). -user:metta_file_buffer(25,373001331,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1075,7),line_char(1075,9))). -user:metta_file_buffer(25,373001331,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1075,10),line_char(1075,14))). -user:metta_file_buffer(25,373001331,variable,_213174,['_then'=_213174],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1075,15),line_char(1075,20))). -user:metta_file_buffer(25,373001331,variable,_214466,['_else'=_214466],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1075,21),line_char(1075,26))). -user:metta_file_buffer(24,373001331,indexed(metta_other,[if,'True',_215320,_215342]),[if,'True',_215400,_215406],['_else'=_215406,'_then'=_215400],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1075,6),line_char(1075,27))). -user:metta_file_buffer(24,373001331,variable,_216398,['_then'=_216398],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1075,28),line_char(1075,33))). -user:metta_file_buffer(23,373001331,indexed(metta_other,['ALT=',[if,'True',_217262,_217284],_217262]),['ALT=',[if,'True',_217372,_217378],_217372],['_else'=_217378,'_then'=_217372],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1075,0),line_char(1075,34))). -user:metta_file_buffer(24,374001332,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1076,1),line_char(1076,5))). -user:metta_file_buffer(25,374001333,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1076,7),line_char(1076,9))). -user:metta_file_buffer(25,374001333,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1076,10),line_char(1076,15))). -user:metta_file_buffer(25,374001333,variable,_213668,['_then'=_213668],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1076,16),line_char(1076,21))). -user:metta_file_buffer(25,374001333,variable,_214960,['_else'=_214960],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1076,22),line_char(1076,27))). -user:metta_file_buffer(24,374001333,indexed(metta_other,[if,'False',_215814,_215836]),[if,'False',_215894,_215900],['_else'=_215900,'_then'=_215894],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1076,6),line_char(1076,28))). -user:metta_file_buffer(24,374001333,variable,_216892,['_else'=_216892],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1076,29),line_char(1076,34))). -user:metta_file_buffer(23,374001333,indexed(metta_other,['ALT=',[if,'False',_217756,_217778],_217778]),['ALT=',[if,'False',_217866,_217872],_217872],['_else'=_217872,'_then'=_217866],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1076,0),line_char(1076,35))). -user:metta_file_buffer(23,375001333,indexed(metta_comment,";`$then`, `$else` should be of `Atom` type to avoid evaluation"),'$COMMENT'(";`$then`, `$else` should be of `Atom` type to avoid evaluation",1077,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1077,0),line_char(1077,62))). -user:metta_file_buffer(23,375001333,indexed(metta_comment,"; and infinite cycle in inference"),'$COMMENT'("; and infinite cycle in inference",1078,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1078,0),line_char(1078,33))). -user:metta_file_buffer(24,375001334,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1081,1),line_char(1081,3))). -user:metta_file_buffer(24,375001334,constant,or,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1081,4),line_char(1081,6))). -user:metta_file_buffer(24,375001334,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1081,7),line_char(1081,12))). -user:metta_file_buffer(23,375001334,metta_other,[iz,or,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1081,0),line_char(1081,13))). -user:metta_file_buffer(24,376001335,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1082,1),line_char(1082,5))). -user:metta_file_buffer(24,376001335,constant,or,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1082,6),line_char(1082,8))). -user:metta_file_buffer(25,376001336,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1083,3),line_char(1083,8))). -user:metta_file_buffer(25,376001336,string,"Logical disjunction of two arguments",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1083,9),line_char(1083,47))). -user:metta_file_buffer(24,376001336,metta_other,['@desc',"Logical disjunction of two arguments"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1083,2),line_char(1083,48))). -user:metta_file_buffer(25,376001337,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1084,3),line_char(1084,10))). -user:metta_file_buffer(27,376001339,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1085,5),line_char(1085,11))). -user:metta_file_buffer(27,376001339,string,"First argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1085,12),line_char(1085,28))). -user:metta_file_buffer(26,376001339,metta_other,['@param',"First argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1085,4),line_char(1085,29))). -user:metta_file_buffer(27,376001340,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1086,5),line_char(1086,11))). -user:metta_file_buffer(27,376001340,string,"Second argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1086,12),line_char(1086,29))). -user:metta_file_buffer(26,376001340,metta_other,['@param',"Second argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1086,4),line_char(1086,30))). -user:metta_file_buffer(25,376001340,array,[['@param',"First argument"],['@param',"Second argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1084,11),line_char(1086,31))). -user:metta_file_buffer(24,376001340,metta_other,['@params',[['@param',"First argument"],['@param',"Second argument"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1084,2),line_char(1086,32))). -user:metta_file_buffer(25,376001341,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1087,3),line_char(1087,10))). -user:metta_file_buffer(25,376001341,string,"True if any of input arguments is True, False - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1087,11),line_char(1087,70))). -user:metta_file_buffer(24,376001341,metta_other,['@return',"True if any of input arguments is True, False - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1087,2),line_char(1087,71))). -user:metta_file_buffer(23,376001341,metta_other,['@doc',or,['@desc',"Logical disjunction of two arguments"],['@params',[['@param',"First argument"],['@param',"Second argument"]]],['@return',"True if any of input arguments is True, False - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1082,0),line_char(1087,72))). -user:metta_file_buffer(24,377001342,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1088,1),line_char(1088,2))). -user:metta_file_buffer(24,377001342,constant,or,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1088,3),line_char(1088,5))). -user:metta_file_buffer(25,377001343,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1088,7),line_char(1088,9))). -user:metta_file_buffer(25,377001343,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1088,10),line_char(1088,14))). -user:metta_file_buffer(25,377001343,constant,'LazyBool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1088,15),line_char(1088,23))). -user:metta_file_buffer(25,377001343,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1088,24),line_char(1088,28))). -user:metta_file_buffer(24,377001343,metta_other,[->,'Bool','LazyBool','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1088,6),line_char(1088,29))). -user:metta_file_buffer(23,377001343,metta_typedecl,[:,or,[->,'Bool','LazyBool','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1088,0),line_char(1088,30))). -user:metta_file_buffer(24,378001344,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1089,1),line_char(1089,5))). -user:metta_file_buffer(25,378001345,constant,or,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1089,7),line_char(1089,9))). -user:metta_file_buffer(25,378001345,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1089,10),line_char(1089,15))). -user:metta_file_buffer(25,378001345,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1089,16),line_char(1089,21))). -user:metta_file_buffer(24,378001345,metta_other,[or,'False','False'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1089,6),line_char(1089,22))). -user:metta_file_buffer(24,378001345,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1089,23),line_char(1089,28))). -user:metta_file_buffer(23,378001345,metta_other,['ALT=',[or,'False','False'],'False'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1089,0),line_char(1089,29))). -user:metta_file_buffer(24,379001346,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1090,1),line_char(1090,5))). -user:metta_file_buffer(25,379001347,constant,or,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1090,7),line_char(1090,9))). -user:metta_file_buffer(25,379001347,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1090,10),line_char(1090,15))). -user:metta_file_buffer(25,379001347,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1090,16),line_char(1090,20))). -user:metta_file_buffer(24,379001347,metta_other,[or,'False','True'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1090,6),line_char(1090,21))). -user:metta_file_buffer(24,379001347,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1090,22),line_char(1090,26))). -user:metta_file_buffer(23,379001347,metta_other,['ALT=',[or,'False','True'],'True'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1090,0),line_char(1090,27))). -user:metta_file_buffer(24,380001348,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1091,1),line_char(1091,5))). -user:metta_file_buffer(25,380001349,constant,or,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1091,7),line_char(1091,9))). -user:metta_file_buffer(25,380001349,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1091,10),line_char(1091,14))). -user:metta_file_buffer(25,380001349,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1091,15),line_char(1091,20))). -user:metta_file_buffer(24,380001349,metta_other,[or,'True','False'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1091,6),line_char(1091,21))). -user:metta_file_buffer(24,380001349,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1091,22),line_char(1091,26))). -user:metta_file_buffer(23,380001349,metta_other,['ALT=',[or,'True','False'],'True'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1091,0),line_char(1091,27))). -user:metta_file_buffer(24,381001350,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1092,1),line_char(1092,5))). -user:metta_file_buffer(25,381001351,constant,or,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1092,7),line_char(1092,9))). -user:metta_file_buffer(25,381001351,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1092,10),line_char(1092,14))). -user:metta_file_buffer(25,381001351,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1092,15),line_char(1092,19))). -user:metta_file_buffer(24,381001351,metta_other,[or,'True','True'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1092,6),line_char(1092,20))). -user:metta_file_buffer(24,381001351,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1092,21),line_char(1092,25))). -user:metta_file_buffer(23,381001351,metta_other,['ALT=',[or,'True','True'],'True'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1092,0),line_char(1092,26))). -user:metta_file_buffer(24,382001352,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1094,1),line_char(1094,3))). -user:metta_file_buffer(24,382001352,constant,and,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1094,4),line_char(1094,7))). -user:metta_file_buffer(24,382001352,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1094,8),line_char(1094,13))). -user:metta_file_buffer(23,382001352,metta_other,[iz,and,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1094,0),line_char(1094,14))). -user:metta_file_buffer(24,383001353,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1095,1),line_char(1095,5))). -user:metta_file_buffer(24,383001353,constant,and,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1095,6),line_char(1095,9))). -user:metta_file_buffer(25,383001354,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1096,3),line_char(1096,8))). -user:metta_file_buffer(25,383001354,string,"Logical conjunction of two arguments",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1096,9),line_char(1096,47))). -user:metta_file_buffer(24,383001354,metta_other,['@desc',"Logical conjunction of two arguments"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1096,2),line_char(1096,48))). -user:metta_file_buffer(25,383001355,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1097,3),line_char(1097,10))). -user:metta_file_buffer(27,383001357,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1098,5),line_char(1098,11))). -user:metta_file_buffer(27,383001357,string,"First argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1098,12),line_char(1098,28))). -user:metta_file_buffer(26,383001357,metta_other,['@param',"First argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1098,4),line_char(1098,29))). -user:metta_file_buffer(27,383001358,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1099,5),line_char(1099,11))). -user:metta_file_buffer(27,383001358,string,"Second argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1099,12),line_char(1099,29))). -user:metta_file_buffer(26,383001358,metta_other,['@param',"Second argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1099,4),line_char(1099,30))). -user:metta_file_buffer(25,383001358,array,[['@param',"First argument"],['@param',"Second argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1097,11),line_char(1099,31))). -user:metta_file_buffer(24,383001358,metta_other,['@params',[['@param',"First argument"],['@param',"Second argument"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1097,2),line_char(1099,32))). -user:metta_file_buffer(25,383001359,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1100,3),line_char(1100,10))). -user:metta_file_buffer(25,383001359,string,"Returns True if both arguments are True, False - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1100,11),line_char(1100,71))). -user:metta_file_buffer(24,383001359,metta_other,['@return',"Returns True if both arguments are True, False - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1100,2),line_char(1100,72))). -user:metta_file_buffer(23,383001359,metta_other,['@doc',and,['@desc',"Logical conjunction of two arguments"],['@params',[['@param',"First argument"],['@param',"Second argument"]]],['@return',"Returns True if both arguments are True, False - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1095,0),line_char(1100,73))). -user:metta_file_buffer(24,384001360,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1101,1),line_char(1101,2))). -user:metta_file_buffer(24,384001360,constant,and,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1101,3),line_char(1101,6))). -user:metta_file_buffer(25,384001361,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1101,8),line_char(1101,10))). -user:metta_file_buffer(25,384001361,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1101,11),line_char(1101,15))). -user:metta_file_buffer(25,384001361,constant,'LazyBool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1101,16),line_char(1101,24))). -user:metta_file_buffer(25,384001361,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1101,25),line_char(1101,29))). -user:metta_file_buffer(24,384001361,metta_other,[->,'Bool','LazyBool','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1101,7),line_char(1101,30))). -user:metta_file_buffer(23,384001361,metta_typedecl,[:,and,[->,'Bool','LazyBool','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1101,0),line_char(1101,31))). -user:metta_file_buffer(24,385001362,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1102,1),line_char(1102,5))). -user:metta_file_buffer(25,385001363,constant,and,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1102,7),line_char(1102,10))). -user:metta_file_buffer(25,385001363,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1102,11),line_char(1102,16))). -user:metta_file_buffer(25,385001363,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1102,17),line_char(1102,22))). -user:metta_file_buffer(24,385001363,metta_other,[and,'False','False'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1102,6),line_char(1102,23))). -user:metta_file_buffer(24,385001363,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1102,24),line_char(1102,29))). -user:metta_file_buffer(23,385001363,metta_other,['ALT=',[and,'False','False'],'False'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1102,0),line_char(1102,30))). -user:metta_file_buffer(24,386001364,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1103,1),line_char(1103,5))). -user:metta_file_buffer(25,386001365,constant,and,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1103,7),line_char(1103,10))). -user:metta_file_buffer(25,386001365,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1103,11),line_char(1103,16))). -user:metta_file_buffer(25,386001365,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1103,17),line_char(1103,21))). -user:metta_file_buffer(24,386001365,metta_other,[and,'False','True'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1103,6),line_char(1103,22))). -user:metta_file_buffer(24,386001365,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1103,23),line_char(1103,28))). -user:metta_file_buffer(23,386001365,metta_other,['ALT=',[and,'False','True'],'False'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1103,0),line_char(1103,29))). -user:metta_file_buffer(24,387001366,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1104,1),line_char(1104,5))). -user:metta_file_buffer(25,387001367,constant,and,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1104,7),line_char(1104,10))). -user:metta_file_buffer(25,387001367,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1104,11),line_char(1104,15))). -user:metta_file_buffer(25,387001367,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1104,16),line_char(1104,21))). -user:metta_file_buffer(24,387001367,metta_other,[and,'True','False'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1104,6),line_char(1104,22))). -user:metta_file_buffer(24,387001367,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1104,23),line_char(1104,28))). -user:metta_file_buffer(23,387001367,metta_other,['ALT=',[and,'True','False'],'False'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1104,0),line_char(1104,29))). -user:metta_file_buffer(24,388001368,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1105,1),line_char(1105,5))). -user:metta_file_buffer(25,388001369,constant,and,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1105,7),line_char(1105,10))). -user:metta_file_buffer(25,388001369,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1105,11),line_char(1105,15))). -user:metta_file_buffer(25,388001369,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1105,16),line_char(1105,20))). -user:metta_file_buffer(24,388001369,metta_other,[and,'True','True'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1105,6),line_char(1105,21))). -user:metta_file_buffer(24,388001369,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1105,22),line_char(1105,26))). -user:metta_file_buffer(23,388001369,metta_other,['ALT=',[and,'True','True'],'True'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1105,0),line_char(1105,27))). -user:metta_file_buffer(24,389001370,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1107,1),line_char(1107,3))). -user:metta_file_buffer(24,389001370,constant,not,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1107,4),line_char(1107,7))). -user:metta_file_buffer(24,389001370,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1107,8),line_char(1107,13))). -user:metta_file_buffer(23,389001370,metta_other,[iz,not,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1107,0),line_char(1107,14))). -user:metta_file_buffer(24,390001371,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1108,1),line_char(1108,5))). -user:metta_file_buffer(24,390001371,constant,not,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1108,6),line_char(1108,9))). -user:metta_file_buffer(25,390001372,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1109,3),line_char(1109,8))). -user:metta_file_buffer(25,390001372,string,"Logical negation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1109,9),line_char(1109,27))). -user:metta_file_buffer(24,390001372,metta_other,['@desc',"Logical negation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1109,2),line_char(1109,28))). -user:metta_file_buffer(25,390001373,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1110,3),line_char(1110,10))). -user:metta_file_buffer(27,390001375,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1111,5),line_char(1111,11))). -user:metta_file_buffer(27,390001375,string,"Argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1111,12),line_char(1111,22))). -user:metta_file_buffer(26,390001375,metta_other,['@param',"Argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1111,4),line_char(1111,23))). -user:metta_file_buffer(25,390001375,array,[['@param',"Argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1110,11),line_char(1111,24))). -user:metta_file_buffer(24,390001375,metta_other,['@params',[['@param',"Argument"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1110,2),line_char(1111,25))). -user:metta_file_buffer(25,390001376,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1112,3),line_char(1112,10))). -user:metta_file_buffer(25,390001376,string,"Negates boolean input argument (False -> True, True -> False)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1112,11),line_char(1112,74))). -user:metta_file_buffer(24,390001376,metta_other,['@return',"Negates boolean input argument (False -> True, True -> False)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1112,2),line_char(1112,75))). -user:metta_file_buffer(23,390001376,metta_other,['@doc',not,['@desc',"Logical negation"],['@params',[['@param',"Argument"]]],['@return',"Negates boolean input argument (False -> True, True -> False)"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1108,0),line_char(1112,76))). -user:metta_file_buffer(24,391001377,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1113,1),line_char(1113,2))). -user:metta_file_buffer(24,391001377,constant,not,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1113,3),line_char(1113,6))). -user:metta_file_buffer(25,391001378,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1113,8),line_char(1113,10))). -user:metta_file_buffer(25,391001378,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1113,11),line_char(1113,15))). -user:metta_file_buffer(25,391001378,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1113,16),line_char(1113,20))). -user:metta_file_buffer(24,391001378,metta_other,[->,'Bool','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1113,7),line_char(1113,21))). -user:metta_file_buffer(23,391001378,metta_typedecl,[:,not,[->,'Bool','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1113,0),line_char(1113,22))). -user:metta_file_buffer(24,392001379,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1114,1),line_char(1114,5))). -user:metta_file_buffer(25,392001380,constant,not,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1114,7),line_char(1114,10))). -user:metta_file_buffer(25,392001380,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1114,11),line_char(1114,15))). -user:metta_file_buffer(24,392001380,metta_other,[not,'True'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1114,6),line_char(1114,16))). -user:metta_file_buffer(24,392001380,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1114,17),line_char(1114,22))). -user:metta_file_buffer(23,392001380,metta_other,['ALT=',[not,'True'],'False'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1114,0),line_char(1114,23))). -user:metta_file_buffer(24,393001381,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1115,1),line_char(1115,5))). -user:metta_file_buffer(25,393001382,constant,not,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1115,7),line_char(1115,10))). -user:metta_file_buffer(25,393001382,constant,'False',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1115,11),line_char(1115,16))). -user:metta_file_buffer(24,393001382,metta_other,[not,'False'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1115,6),line_char(1115,17))). -user:metta_file_buffer(24,393001382,constant,'True',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1115,18),line_char(1115,22))). -user:metta_file_buffer(23,393001382,metta_other,['ALT=',[not,'False'],'True'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1115,0),line_char(1115,23))). -user:metta_file_buffer(24,394001383,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1117,1),line_char(1117,3))). -user:metta_file_buffer(24,394001383,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1117,4),line_char(1117,7))). -user:metta_file_buffer(24,394001383,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1117,8),line_char(1117,13))). -user:metta_file_buffer(23,394001383,metta_other,[iz,let,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1117,0),line_char(1117,14))). -user:metta_file_buffer(24,395001384,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1118,1),line_char(1118,5))). -user:metta_file_buffer(24,395001384,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1118,6),line_char(1118,9))). -user:metta_file_buffer(25,395001385,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1119,3),line_char(1119,8))). -user:metta_file_buffer(25,395001385,string,"Let function is utilized to establish temporary variable bindings within an expression. It allows introducing variables (first argument), assign values to them (second argument), and then use these values within the scope of the let block",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1119,9),line_char(1119,249))). -user:metta_file_buffer(24,395001385,metta_other,['@desc',"Let function is utilized to establish temporary variable bindings within an expression. It allows introducing variables (first argument), assign values to them (second argument), and then use these values within the scope of the let block"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1119,2),line_char(1119,250))). -user:metta_file_buffer(25,395001386,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1120,3),line_char(1120,10))). -user:metta_file_buffer(27,395001388,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1121,5),line_char(1121,11))). -user:metta_file_buffer(27,395001388,string,"Variable name (or several variables inside brackets ())",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1121,12),line_char(1121,69))). -user:metta_file_buffer(26,395001388,metta_other,['@param',"Variable name (or several variables inside brackets ())"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1121,4),line_char(1121,70))). -user:metta_file_buffer(27,395001389,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1122,5),line_char(1122,11))). -user:metta_file_buffer(27,395001389,string,"Expression to be bound to variable (it is being reduced before bind)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1122,12),line_char(1122,82))). -user:metta_file_buffer(26,395001389,metta_other,['@param',"Expression to be bound to variable (it is being reduced before bind)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1122,4),line_char(1122,83))). -user:metta_file_buffer(27,395001390,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1123,5),line_char(1123,11))). -user:metta_file_buffer(27,395001390,string,"Expression which will be reduced and in which variable (first argument) could be used",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1123,12),line_char(1123,99))). -user:metta_file_buffer(26,395001390,metta_other,['@param',"Expression which will be reduced and in which variable (first argument) could be used"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1123,4),line_char(1123,100))). -user:metta_file_buffer(25,395001390,array,[['@param',"Variable name (or several variables inside brackets ())"],['@param',"Expression to be bound to variable (it is being reduced before bind)"],['@param',"Expression which will be reduced and in which variable (first argument) could be used"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1120,11),line_char(1123,101))). -user:metta_file_buffer(24,395001390,metta_other,['@params',[['@param',"Variable name (or several variables inside brackets ())"],['@param',"Expression to be bound to variable (it is being reduced before bind)"],['@param',"Expression which will be reduced and in which variable (first argument) could be used"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1120,2),line_char(1123,102))). -user:metta_file_buffer(25,395001391,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1124,3),line_char(1124,10))). -user:metta_file_buffer(25,395001391,string,"Result of third argument's evaluation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1124,11),line_char(1124,50))). -user:metta_file_buffer(24,395001391,metta_other,['@return',"Result of third argument's evaluation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1124,2),line_char(1124,51))). -user:metta_file_buffer(23,395001391,metta_other,['@doc',let,['@desc',"Let function is utilized to establish temporary variable bindings within an expression. It allows introducing variables (first argument), assign values to them (second argument), and then use these values within the scope of the let block"],['@params',[['@param',"Variable name (or several variables inside brackets ())"],['@param',"Expression to be bound to variable (it is being reduced before bind)"],['@param',"Expression which will be reduced and in which variable (first argument) could be used"]]],['@return',"Result of third argument's evaluation"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1118,0),line_char(1124,52))). -user:metta_file_buffer(24,396001392,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1125,1),line_char(1125,2))). -user:metta_file_buffer(24,396001392,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1125,3),line_char(1125,6))). -user:metta_file_buffer(25,396001393,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1125,8),line_char(1125,10))). -user:metta_file_buffer(25,396001393,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1125,11),line_char(1125,15))). -user:metta_file_buffer(25,396001393,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1125,16),line_char(1125,27))). -user:metta_file_buffer(25,396001393,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1125,28),line_char(1125,32))). -user:metta_file_buffer(25,396001393,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1125,33),line_char(1125,37))). -user:metta_file_buffer(24,396001393,metta_other,[->,'Atom','%Undefined%','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1125,7),line_char(1125,38))). -user:metta_file_buffer(23,396001393,metta_typedecl,[:,let,[->,'Atom','%Undefined%','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1125,0),line_char(1125,39))). -user:metta_file_buffer(24,397001394,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1126,1),line_char(1126,5))). -user:metta_file_buffer(25,397001395,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1126,7),line_char(1126,10))). -user:metta_file_buffer(25,397001395,variable,_221654,['_pattern'=_221654],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1126,11),line_char(1126,19))). -user:metta_file_buffer(25,397001395,variable,_222938,['_atom'=_222938],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1126,20),line_char(1126,25))). -user:metta_file_buffer(25,397001395,variable,_224310,['_template'=_224310],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1126,26),line_char(1126,35))). -user:metta_file_buffer(24,397001395,indexed(metta_other,[let,_225156,_225178,_225200]),[let,_225252,_225258,_225264],['_template'=_225264,'_atom'=_225258,'_pattern'=_225252],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1126,6),line_char(1126,36))). -user:metta_file_buffer(25,397001396,constant,'if-unify',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1127,3),line_char(1127,11))). -user:metta_file_buffer(25,397001396,variable,_227030,['_atom'=_227030],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1127,12),line_char(1127,17))). -user:metta_file_buffer(25,397001396,variable,_228378,['_pattern'=_228378],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1127,18),line_char(1127,26))). -user:metta_file_buffer(25,397001396,variable,_229742,['_template'=_229742],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1127,27),line_char(1127,36))). -user:metta_file_buffer(25,397001396,constant,'Empty',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1127,37),line_char(1127,42))). -user:metta_file_buffer(24,397001396,indexed(metta_other,['if-unify',_231200,_231222,_231244,'Empty']),['if-unify',_231304,_231310,_231316,'Empty'],['_template'=_231316,'_pattern'=_231310,'_atom'=_231304],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1127,2),line_char(1127,43))). -user:metta_file_buffer(23,397001396,indexed(metta_other,['ALT=',[let,_231884,_231906,_231928],['if-unify',_231906,_231884,_231928,'Empty']]),['ALT=',[let,_232070,_232076,_232082],['if-unify',_232076,_232070,_232082,'Empty']],['_template'=_232082,'_atom'=_232076,'_pattern'=_232070],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1126,0),line_char(1127,44))). -user:metta_file_buffer(24,398001397,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1129,1),line_char(1129,3))). -user:metta_file_buffer(24,398001397,constant,'let*',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1129,4),line_char(1129,8))). -user:metta_file_buffer(24,398001397,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1129,9),line_char(1129,14))). -user:metta_file_buffer(23,398001397,metta_other,[iz,'let*','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1129,0),line_char(1129,15))). -user:metta_file_buffer(24,399001398,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1130,1),line_char(1130,5))). -user:metta_file_buffer(24,399001398,constant,'let*',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1130,6),line_char(1130,10))). -user:metta_file_buffer(25,399001399,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1131,3),line_char(1131,8))). -user:metta_file_buffer(25,399001399,string,"Same as let, but first argument is a tuple containing tuples of variables and their bindings, e.g. (($v (+ 1 2)) ($v2 (* 5 6)))",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1131,9),line_char(1131,138))). -user:metta_file_buffer(24,399001399,metta_other,['@desc',"Same as let, but first argument is a tuple containing tuples of variables and their bindings, e.g. (($v (+ 1 2)) ($v2 (* 5 6)))"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1131,2),line_char(1131,139))). -user:metta_file_buffer(25,399001400,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1132,3),line_char(1132,10))). -user:metta_file_buffer(27,399001402,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1133,5),line_char(1133,11))). -user:metta_file_buffer(27,399001402,string,"Tuple of tuples with variables and their bindings",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1133,12),line_char(1133,63))). -user:metta_file_buffer(26,399001402,metta_other,['@param',"Tuple of tuples with variables and their bindings"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1133,4),line_char(1133,64))). -user:metta_file_buffer(27,399001403,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1134,5),line_char(1134,11))). -user:metta_file_buffer(27,399001403,string,"Expression which will be evaluated if each pair can be unified",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1134,12),line_char(1134,76))). -user:metta_file_buffer(26,399001403,metta_other,['@param',"Expression which will be evaluated if each pair can be unified"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1134,4),line_char(1134,77))). -user:metta_file_buffer(25,399001403,array,[['@param',"Tuple of tuples with variables and their bindings"],['@param',"Expression which will be evaluated if each pair can be unified"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1132,11),line_char(1134,78))). -user:metta_file_buffer(24,399001403,metta_other,['@params',[['@param',"Tuple of tuples with variables and their bindings"],['@param',"Expression which will be evaluated if each pair can be unified"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1132,2),line_char(1134,79))). -user:metta_file_buffer(25,399001404,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1135,3),line_char(1135,10))). -user:metta_file_buffer(25,399001404,string,"Second argument or Empty",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1135,11),line_char(1135,37))). -user:metta_file_buffer(24,399001404,metta_other,['@return',"Second argument or Empty"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1135,2),line_char(1135,38))). -user:metta_file_buffer(23,399001404,metta_other,['@doc','let*',['@desc',"Same as let, but first argument is a tuple containing tuples of variables and their bindings, e.g. (($v (+ 1 2)) ($v2 (* 5 6)))"],['@params',[['@param',"Tuple of tuples with variables and their bindings"],['@param',"Expression which will be evaluated if each pair can be unified"]]],['@return',"Second argument or Empty"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1130,0),line_char(1135,39))). -user:metta_file_buffer(24,400001405,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1136,1),line_char(1136,2))). -user:metta_file_buffer(24,400001405,constant,'let*',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1136,3),line_char(1136,7))). -user:metta_file_buffer(25,400001406,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1136,9),line_char(1136,11))). -user:metta_file_buffer(25,400001406,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1136,12),line_char(1136,22))). -user:metta_file_buffer(25,400001406,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1136,23),line_char(1136,27))). -user:metta_file_buffer(25,400001406,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1136,28),line_char(1136,39))). -user:metta_file_buffer(24,400001406,metta_other,[->,'Expression','Atom','%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1136,8),line_char(1136,40))). -user:metta_file_buffer(23,400001406,metta_typedecl,[:,'let*',[->,'Expression','Atom','%Undefined%']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1136,0),line_char(1136,41))). -user:metta_file_buffer(24,401001407,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1137,1),line_char(1137,5))). -user:metta_file_buffer(25,401001408,constant,'let*',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1137,7),line_char(1137,11))). -user:metta_file_buffer(25,401001408,variable,_228230,['_pairs'=_228230],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1137,12),line_char(1137,18))). -user:metta_file_buffer(25,401001408,variable,_229602,['_template'=_229602],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1137,19),line_char(1137,28))). -user:metta_file_buffer(24,401001408,indexed(metta_other,['let*',_230442,_230464]),['let*',_230516,_230522],['_template'=_230522,'_pairs'=_230516],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1137,6),line_char(1137,29))). -user:metta_file_buffer(25,401001409,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1138,3),line_char(1138,7))). -user:metta_file_buffer(26,401001410,constant,'if-decons-expr',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1138,9),line_char(1138,23))). -user:metta_file_buffer(26,401001410,variable,_233146,['_pairs'=_233146],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1138,24),line_char(1138,30))). -user:metta_file_buffer(27,401001411,variable,_234632,['_pattern'=_234632],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1138,32),line_char(1138,40))). -user:metta_file_buffer(27,401001411,variable,_235924,['_atom'=_235924],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1138,41),line_char(1138,46))). -user:metta_file_buffer(26,401001411,indexed(metta_other,[_236750,_236772]),[_236818,_236824],['_atom'=_236824,'_pattern'=_236818],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1138,31),line_char(1138,47))). -user:metta_file_buffer(26,401001411,variable,_237808,['_tail'=_237808],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1138,48),line_char(1138,53))). -user:metta_file_buffer(27,401001412,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1139,5),line_char(1139,8))). -user:metta_file_buffer(27,401001412,variable,_239948,['_pattern'=_239948],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1139,9),line_char(1139,17))). -user:metta_file_buffer(27,401001412,variable,_241232,['_atom'=_241232],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1139,18),line_char(1139,23))). -user:metta_file_buffer(28,401001413,constant,'let*',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1139,25),line_char(1139,29))). -user:metta_file_buffer(28,401001413,variable,_243352,['_tail'=_243352],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1139,30),line_char(1139,35))). -user:metta_file_buffer(28,401001413,variable,_244724,['_template'=_244724],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1139,36),line_char(1139,45))). -user:metta_file_buffer(27,401001413,indexed(metta_other,['let*',_245564,_245586]),['let*',_245638,_245644],['_template'=_245644,'_tail'=_245638],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1139,24),line_char(1139,46))). -user:metta_file_buffer(26,401001413,indexed(metta_other,[let,_246190,_246212,['let*',_246250,_246272]]),[let,_246324,_246330,['let*',_246348,_246354]],['_template'=_246354,'_tail'=_246348,'_atom'=_246330,'_pattern'=_246324],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1139,4),line_char(1139,47))). -user:metta_file_buffer(26,401001413,variable,_247450,['_template'=_247450],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1140,4),line_char(1140,13))). -user:metta_file_buffer(25,401001413,indexed(metta_other,['if-decons-expr',_248310,[_248340,_248362],_248384,[let,_248340,_248362,['let*',_248384,_248492]],_248492]),['if-decons-expr',_248562,[_248574,_248580],_248586,[let,_248574,_248580,['let*',_248586,_248634]],_248634],['_template'=_248634,'_tail'=_248586,'_atom'=_248580,'_pattern'=_248574,'_pairs'=_248562],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1138,8),line_char(1140,15))). -user:metta_file_buffer(24,401001413,indexed(metta_other,[eval,['if-decons-expr',_249226,[_249256,_249278],_249300,[let,_249256,_249278,['let*',_249300,_249408]],_249408]]),[eval,['if-decons-expr',_249490,[_249502,_249508],_249514,[let,_249502,_249508,['let*',_249514,_249562]],_249562]],['_template'=_249562,'_tail'=_249514,'_atom'=_249508,'_pattern'=_249502,'_pairs'=_249490],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1138,2),line_char(1140,16))). -user:metta_file_buffer(23,401001413,indexed(metta_other,['ALT=',['let*',_250160,_250182],[eval,['if-decons-expr',_250160,[_250262,_250284],_250306,[let,_250262,_250284,['let*',_250306,_250182]],_250182]]]),['ALT=',['let*',_250492,_250498],[eval,['if-decons-expr',_250492,[_250540,_250546],_250552,[let,_250540,_250546,['let*',_250552,_250498]],_250498]]],['_tail'=_250552,'_atom'=_250546,'_pattern'=_250540,'_template'=_250498,'_pairs'=_250492],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1137,0),line_char(1140,17))). -user:metta_file_buffer(24,402001414,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1142,1),line_char(1142,3))). -user:metta_file_buffer(24,402001414,constant,'add-reduct',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1142,4),line_char(1142,14))). -user:metta_file_buffer(24,402001414,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1142,15),line_char(1142,20))). -user:metta_file_buffer(23,402001414,metta_other,[iz,'add-reduct','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1142,0),line_char(1142,21))). -user:metta_file_buffer(24,403001415,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1143,1),line_char(1143,5))). -user:metta_file_buffer(24,403001415,constant,'add-reduct',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1143,6),line_char(1143,16))). -user:metta_file_buffer(25,403001416,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1144,3),line_char(1144,8))). -user:metta_file_buffer(25,403001416,string,"Prevents atom from being reduced",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1144,9),line_char(1144,43))). -user:metta_file_buffer(24,403001416,metta_other,['@desc',"Prevents atom from being reduced"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1144,2),line_char(1144,44))). -user:metta_file_buffer(25,403001417,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1145,3),line_char(1145,10))). -user:metta_file_buffer(27,403001419,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1146,5),line_char(1146,11))). -user:metta_file_buffer(27,403001419,string,"Atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1146,12),line_char(1146,18))). -user:metta_file_buffer(26,403001419,metta_other,['@param',"Atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1146,4),line_char(1146,19))). -user:metta_file_buffer(25,403001419,array,[['@param',"Atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1145,11),line_char(1146,20))). -user:metta_file_buffer(24,403001419,metta_other,['@params',[['@param',"Atom"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1145,2),line_char(1146,21))). -user:metta_file_buffer(25,403001420,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1147,3),line_char(1147,10))). -user:metta_file_buffer(25,403001420,string,"Quoted atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1147,11),line_char(1147,24))). -user:metta_file_buffer(24,403001420,metta_other,['@return',"Quoted atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1147,2),line_char(1147,25))). -user:metta_file_buffer(23,403001420,metta_other,['@doc','add-reduct',['@desc',"Prevents atom from being reduced"],['@params',[['@param',"Atom"]]],['@return',"Quoted atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1143,0),line_char(1147,26))). -user:metta_file_buffer(24,404001421,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1149,1),line_char(1149,5))). -user:metta_file_buffer(24,404001421,constant,'add-reduct-rust1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1149,6),line_char(1149,22))). -user:metta_file_buffer(25,404001422,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1150,3),line_char(1150,8))). -user:metta_file_buffer(25,404001422,string,"Adds atom into the atomspace reducing it first",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1150,9),line_char(1150,57))). -user:metta_file_buffer(24,404001422,metta_other,['@desc',"Adds atom into the atomspace reducing it first"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1150,2),line_char(1150,58))). -user:metta_file_buffer(25,404001423,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1151,3),line_char(1151,10))). -user:metta_file_buffer(27,404001425,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1152,5),line_char(1152,11))). -user:metta_file_buffer(27,404001425,string,"Atomspace to add atom into",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1152,12),line_char(1152,40))). -user:metta_file_buffer(26,404001425,metta_other,['@param',"Atomspace to add atom into"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1152,4),line_char(1152,41))). -user:metta_file_buffer(27,404001426,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1153,5),line_char(1153,11))). -user:metta_file_buffer(27,404001426,string,"Atom to add",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1153,12),line_char(1153,25))). -user:metta_file_buffer(26,404001426,metta_other,['@param',"Atom to add"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1153,4),line_char(1153,26))). -user:metta_file_buffer(25,404001426,array,[['@param',"Atomspace to add atom into"],['@param',"Atom to add"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1151,11),line_char(1153,27))). -user:metta_file_buffer(24,404001426,metta_other,['@params',[['@param',"Atomspace to add atom into"],['@param',"Atom to add"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1151,2),line_char(1153,28))). -user:metta_file_buffer(25,404001427,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1154,3),line_char(1154,10))). -user:metta_file_buffer(25,404001427,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1154,11),line_char(1154,22))). -user:metta_file_buffer(24,404001427,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1154,2),line_char(1154,23))). -user:metta_file_buffer(23,404001427,metta_other,['@doc','add-reduct-rust1',['@desc',"Adds atom into the atomspace reducing it first"],['@params',[['@param',"Atomspace to add atom into"],['@param',"Atom to add"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1149,0),line_char(1154,24))). -user:metta_file_buffer(24,405001428,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1156,1),line_char(1156,2))). -user:metta_file_buffer(24,405001428,constant,'add-reduct-rust1',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1156,3),line_char(1156,19))). -user:metta_file_buffer(25,405001429,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1156,21),line_char(1156,23))). -user:metta_file_buffer(25,405001429,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1156,24),line_char(1156,48))). -user:metta_file_buffer(25,405001429,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1156,49),line_char(1156,60))). -user:metta_file_buffer(26,405001430,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1156,62),line_char(1156,64))). -user:metta_file_buffer(25,405001430,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1156,61),line_char(1156,65))). -user:metta_file_buffer(24,405001430,metta_other,[->,'hyperon::space::DynSpace','%Undefined%',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1156,20),line_char(1156,66))). -user:metta_file_buffer(23,405001430,metta_typedecl,[:,'add-reduct-rust1',[->,'hyperon::space::DynSpace','%Undefined%',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1156,0),line_char(1156,67))). -user:metta_file_buffer(24,406001431,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1157,1),line_char(1157,2))). -user:metta_file_buffer(25,406001432,constant,'add-reduct-minimal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1157,4),line_char(1157,22))). -user:metta_file_buffer(25,406001432,variable,_248182,['_dst'=_248182],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1157,23),line_char(1157,27))). -user:metta_file_buffer(25,406001432,variable,_249474,['_atom'=_249474],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1157,28),line_char(1157,33))). -user:metta_file_buffer(24,406001432,indexed(metta_other,['add-reduct-minimal',_250314,_250336]),['add-reduct-minimal',_250388,_250394],['_atom'=_250394,'_dst'=_250388],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1157,3),line_char(1157,34))). -user:metta_file_buffer(25,406001433,constant,'add-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1157,36),line_char(1157,44))). -user:metta_file_buffer(25,406001433,variable,_252128,['_dst'=_252128],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1157,45),line_char(1157,49))). -user:metta_file_buffer(25,406001433,variable,_253420,['_atom'=_253420],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1157,50),line_char(1157,55))). -user:metta_file_buffer(24,406001433,indexed(metta_other,['add-atom',_254260,_254282]),['add-atom',_254334,_254340],['_atom'=_254340,'_dst'=_254334],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1157,35),line_char(1157,56))). -user:metta_file_buffer(23,406001433,indexed(metta_defun,['add-reduct-minimal',_254896,_254918]),[=,['add-reduct-minimal',_255034,_255040],['add-atom',_255034,_255040]],['_atom'=_255040,'_dst'=_255034],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1157,0),line_char(1157,57))). -user:metta_file_buffer(24,407001434,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1158,1),line_char(1158,3))). -user:metta_file_buffer(24,407001434,constant,'add-reduct',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1158,4),line_char(1158,14))). -user:metta_file_buffer(24,407001434,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1158,15),line_char(1158,20))). -user:metta_file_buffer(23,407001434,metta_other,[iz,'add-reduct','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1158,0),line_char(1158,21))). -user:metta_file_buffer(24,408001435,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1159,1),line_char(1159,2))). -user:metta_file_buffer(24,408001435,constant,'add-reduct',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1159,3),line_char(1159,13))). -user:metta_file_buffer(25,408001436,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1159,15),line_char(1159,17))). -user:metta_file_buffer(25,408001436,constant,'Grounded',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1159,18),line_char(1159,26))). -user:metta_file_buffer(25,408001436,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1159,27),line_char(1159,38))). -user:metta_file_buffer(26,408001437,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1159,40),line_char(1159,42))). -user:metta_file_buffer(25,408001437,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1159,39),line_char(1159,43))). -user:metta_file_buffer(24,408001437,metta_other,[->,'Grounded','%Undefined%',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1159,14),line_char(1159,44))). -user:metta_file_buffer(23,408001437,metta_typedecl,[:,'add-reduct',[->,'Grounded','%Undefined%',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1159,0),line_char(1159,45))). -user:metta_file_buffer(24,409001438,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1160,1),line_char(1160,2))). -user:metta_file_buffer(25,409001439,constant,'add-reduct',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1160,4),line_char(1160,14))). -user:metta_file_buffer(25,409001439,variable,_251330,['_dst'=_251330],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1160,15),line_char(1160,19))). -user:metta_file_buffer(25,409001439,variable,_252622,['_atom'=_252622],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1160,20),line_char(1160,25))). -user:metta_file_buffer(24,409001439,indexed(metta_other,['add-reduct',_253462,_253484]),['add-reduct',_253536,_253542],['_atom'=_253542,'_dst'=_253536],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1160,3),line_char(1160,26))). -user:metta_file_buffer(25,409001440,constant,'add-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1160,28),line_char(1160,36))). -user:metta_file_buffer(25,409001440,variable,_255276,['_dst'=_255276],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1160,37),line_char(1160,41))). -user:metta_file_buffer(25,409001440,variable,_256568,['_atom'=_256568],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1160,42),line_char(1160,47))). -user:metta_file_buffer(24,409001440,indexed(metta_other,['add-atom',_257408,_257430]),['add-atom',_257482,_257488],['_atom'=_257488,'_dst'=_257482],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1160,27),line_char(1160,48))). -user:metta_file_buffer(23,409001440,indexed(metta_defun,['add-reduct',_258044,_258066]),[=,['add-reduct',_258182,_258188],['add-atom',_258182,_258188]],['_atom'=_258188,'_dst'=_258182],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1160,0),line_char(1160,49))). -user:metta_file_buffer(24,410001441,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1163,1),line_char(1163,3))). -user:metta_file_buffer(24,410001441,constant,stringToChars,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1163,4),line_char(1163,17))). -user:metta_file_buffer(24,410001441,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1163,18),line_char(1163,23))). -user:metta_file_buffer(23,410001441,metta_other,[iz,stringToChars,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1163,0),line_char(1163,24))). -user:metta_file_buffer(24,411001442,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1164,1),line_char(1164,5))). -user:metta_file_buffer(24,411001442,constant,stringToChars,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1164,6),line_char(1164,19))). -user:metta_file_buffer(25,411001443,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1165,3),line_char(1165,8))). -user:metta_file_buffer(25,411001443,string,"Converts a string into a list expression of characters.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1165,9),line_char(1165,66))). -user:metta_file_buffer(24,411001443,metta_other,['@desc',"Converts a string into a list expression of characters."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1165,2),line_char(1165,67))). -user:metta_file_buffer(25,411001444,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1166,3),line_char(1166,10))). -user:metta_file_buffer(27,411001446,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1167,5),line_char(1167,11))). -user:metta_file_buffer(27,411001446,string,"String to be converted.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1167,12),line_char(1167,37))). -user:metta_file_buffer(26,411001446,metta_other,['@param',"String to be converted."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1167,4),line_char(1167,38))). -user:metta_file_buffer(25,411001446,array,[['@param',"String to be converted."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1166,11),line_char(1167,39))). -user:metta_file_buffer(24,411001446,metta_other,['@params',[['@param',"String to be converted."]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1166,2),line_char(1167,40))). -user:metta_file_buffer(25,411001447,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1168,3),line_char(1168,10))). -user:metta_file_buffer(25,411001447,string,"Expression representing the list of characters.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1168,11),line_char(1168,60))). -user:metta_file_buffer(24,411001447,metta_other,['@return',"Expression representing the list of characters."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1168,2),line_char(1168,61))). -user:metta_file_buffer(23,411001447,metta_other,['@doc',stringToChars,['@desc',"Converts a string into a list expression of characters."],['@params',[['@param',"String to be converted."]]],['@return',"Expression representing the list of characters."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1164,0),line_char(1168,62))). -user:metta_file_buffer(24,412001448,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1169,1),line_char(1169,2))). -user:metta_file_buffer(24,412001448,constant,stringToChars,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1169,3),line_char(1169,16))). -user:metta_file_buffer(25,412001449,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1169,18),line_char(1169,20))). -user:metta_file_buffer(25,412001449,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1169,21),line_char(1169,27))). -user:metta_file_buffer(25,412001449,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1169,28),line_char(1169,38))). -user:metta_file_buffer(24,412001449,metta_other,[->,'String','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1169,17),line_char(1169,39))). -user:metta_file_buffer(23,412001449,metta_typedecl,[:,stringToChars,[->,'String','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1169,0),line_char(1169,40))). -user:metta_file_buffer(24,413001450,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1171,1),line_char(1171,3))). -user:metta_file_buffer(24,413001450,constant,charsToString,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1171,4),line_char(1171,17))). -user:metta_file_buffer(24,413001450,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1171,18),line_char(1171,23))). -user:metta_file_buffer(23,413001450,metta_other,[iz,charsToString,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1171,0),line_char(1171,24))). -user:metta_file_buffer(24,414001451,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1172,1),line_char(1172,5))). -user:metta_file_buffer(24,414001451,constant,charsToString,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1172,6),line_char(1172,19))). -user:metta_file_buffer(25,414001452,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1173,3),line_char(1173,8))). -user:metta_file_buffer(25,414001452,string,"Converts a list expression of characters into a string.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1173,9),line_char(1173,66))). -user:metta_file_buffer(24,414001452,metta_other,['@desc',"Converts a list expression of characters into a string."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1173,2),line_char(1173,67))). -user:metta_file_buffer(25,414001453,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1174,3),line_char(1174,10))). -user:metta_file_buffer(27,414001455,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1175,5),line_char(1175,11))). -user:metta_file_buffer(27,414001455,string,"Expression representing the list of characters.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1175,12),line_char(1175,61))). -user:metta_file_buffer(26,414001455,metta_other,['@param',"Expression representing the list of characters."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1175,4),line_char(1175,62))). -user:metta_file_buffer(25,414001455,array,[['@param',"Expression representing the list of characters."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1174,11),line_char(1175,63))). -user:metta_file_buffer(24,414001455,metta_other,['@params',[['@param',"Expression representing the list of characters."]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1174,2),line_char(1175,64))). -user:metta_file_buffer(25,414001456,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1176,3),line_char(1176,10))). -user:metta_file_buffer(25,414001456,string,"Converted string.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1176,11),line_char(1176,30))). -user:metta_file_buffer(24,414001456,metta_other,['@return',"Converted string."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1176,2),line_char(1176,31))). -user:metta_file_buffer(23,414001456,metta_other,['@doc',charsToString,['@desc',"Converts a list expression of characters into a string."],['@params',[['@param',"Expression representing the list of characters."]]],['@return',"Converted string."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1172,0),line_char(1176,32))). -user:metta_file_buffer(24,415001457,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1177,1),line_char(1177,2))). -user:metta_file_buffer(24,415001457,constant,charsToString,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1177,3),line_char(1177,16))). -user:metta_file_buffer(25,415001458,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1177,18),line_char(1177,20))). -user:metta_file_buffer(25,415001458,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1177,21),line_char(1177,31))). -user:metta_file_buffer(25,415001458,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1177,32),line_char(1177,38))). -user:metta_file_buffer(24,415001458,metta_other,[->,'Expression','String'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1177,17),line_char(1177,39))). -user:metta_file_buffer(23,415001458,metta_typedecl,[:,charsToString,[->,'Expression','String']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1177,0),line_char(1177,40))). -user:metta_file_buffer(24,416001459,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1179,1),line_char(1179,3))). -user:metta_file_buffer(24,416001459,constant,parse,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1179,4),line_char(1179,9))). -user:metta_file_buffer(24,416001459,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1179,10),line_char(1179,15))). -user:metta_file_buffer(23,416001459,metta_other,[iz,parse,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1179,0),line_char(1179,16))). -user:metta_file_buffer(24,417001460,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1180,1),line_char(1180,5))). -user:metta_file_buffer(24,417001460,constant,parse,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1180,6),line_char(1180,11))). -user:metta_file_buffer(25,417001461,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1181,3),line_char(1181,8))). -user:metta_file_buffer(25,417001461,string,"Parses MeTTa code from a string and returns the corresponding atom.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1181,9),line_char(1181,78))). -user:metta_file_buffer(24,417001461,metta_other,['@desc',"Parses MeTTa code from a string and returns the corresponding atom."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1181,2),line_char(1181,79))). -user:metta_file_buffer(25,417001462,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1182,3),line_char(1182,10))). -user:metta_file_buffer(27,417001464,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1183,5),line_char(1183,11))). -user:metta_file_buffer(27,417001464,string,"String containing MeTTa code.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1183,12),line_char(1183,43))). -user:metta_file_buffer(26,417001464,metta_other,['@param',"String containing MeTTa code."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1183,4),line_char(1183,44))). -user:metta_file_buffer(25,417001464,array,[['@param',"String containing MeTTa code."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1182,11),line_char(1183,45))). -user:metta_file_buffer(24,417001464,metta_other,['@params',[['@param',"String containing MeTTa code."]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1182,2),line_char(1183,46))). -user:metta_file_buffer(25,417001465,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1184,3),line_char(1184,10))). -user:metta_file_buffer(25,417001465,string,"Parsed atom.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1184,11),line_char(1184,25))). -user:metta_file_buffer(24,417001465,metta_other,['@return',"Parsed atom."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1184,2),line_char(1184,26))). -user:metta_file_buffer(23,417001465,metta_other,['@doc',parse,['@desc',"Parses MeTTa code from a string and returns the corresponding atom."],['@params',[['@param',"String containing MeTTa code."]]],['@return',"Parsed atom."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1180,0),line_char(1184,27))). -user:metta_file_buffer(24,418001466,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1185,1),line_char(1185,2))). -user:metta_file_buffer(24,418001466,constant,parse,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1185,3),line_char(1185,8))). -user:metta_file_buffer(25,418001467,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1185,10),line_char(1185,12))). -user:metta_file_buffer(25,418001467,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1185,13),line_char(1185,19))). -user:metta_file_buffer(25,418001467,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1185,20),line_char(1185,24))). -user:metta_file_buffer(24,418001467,metta_other,[->,'String','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1185,9),line_char(1185,25))). -user:metta_file_buffer(23,418001467,metta_typedecl,[:,parse,[->,'String','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1185,0),line_char(1185,26))). -user:metta_file_buffer(24,419001468,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1187,1),line_char(1187,3))). -user:metta_file_buffer(24,419001468,constant,repr,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1187,4),line_char(1187,8))). -user:metta_file_buffer(24,419001468,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1187,9),line_char(1187,14))). -user:metta_file_buffer(23,419001468,metta_other,[iz,repr,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1187,0),line_char(1187,15))). -user:metta_file_buffer(24,420001469,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1188,1),line_char(1188,5))). -user:metta_file_buffer(24,420001469,constant,repr,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1188,6),line_char(1188,10))). -user:metta_file_buffer(25,420001470,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1189,3),line_char(1189,8))). -user:metta_file_buffer(25,420001470,string,"Creates a string representation of an atom.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1189,9),line_char(1189,54))). -user:metta_file_buffer(24,420001470,metta_other,['@desc',"Creates a string representation of an atom."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1189,2),line_char(1189,55))). -user:metta_file_buffer(25,420001471,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1190,3),line_char(1190,10))). -user:metta_file_buffer(27,420001473,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1191,5),line_char(1191,11))). -user:metta_file_buffer(27,420001473,string,"Atom to be represented as a string.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1191,12),line_char(1191,49))). -user:metta_file_buffer(26,420001473,metta_other,['@param',"Atom to be represented as a string."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1191,4),line_char(1191,50))). -user:metta_file_buffer(25,420001473,array,[['@param',"Atom to be represented as a string."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1190,11),line_char(1191,51))). -user:metta_file_buffer(24,420001473,metta_other,['@params',[['@param',"Atom to be represented as a string."]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1190,2),line_char(1191,52))). -user:metta_file_buffer(25,420001474,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1192,3),line_char(1192,10))). -user:metta_file_buffer(25,420001474,string,"String representation of the atom.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1192,11),line_char(1192,47))). -user:metta_file_buffer(24,420001474,metta_other,['@return',"String representation of the atom."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1192,2),line_char(1192,48))). -user:metta_file_buffer(23,420001474,metta_other,['@doc',repr,['@desc',"Creates a string representation of an atom."],['@params',[['@param',"Atom to be represented as a string."]]],['@return',"String representation of the atom."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1188,0),line_char(1192,49))). -user:metta_file_buffer(24,421001475,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1193,1),line_char(1193,2))). -user:metta_file_buffer(24,421001475,constant,repr,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1193,3),line_char(1193,7))). -user:metta_file_buffer(25,421001476,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1193,9),line_char(1193,11))). -user:metta_file_buffer(25,421001476,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1193,12),line_char(1193,16))). -user:metta_file_buffer(25,421001476,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1193,17),line_char(1193,23))). -user:metta_file_buffer(24,421001476,metta_other,[->,'Atom','String'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1193,8),line_char(1193,24))). -user:metta_file_buffer(23,421001476,metta_typedecl,[:,repr,[->,'Atom','String']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1193,0),line_char(1193,25))). -user:metta_file_buffer(24,422001477,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1195,1),line_char(1195,3))). -user:metta_file_buffer(24,422001477,constant,'car-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1195,4),line_char(1195,12))). -user:metta_file_buffer(24,422001477,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1195,13),line_char(1195,18))). -user:metta_file_buffer(23,422001477,metta_other,[iz,'car-atom','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1195,0),line_char(1195,19))). -user:metta_file_buffer(24,423001478,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1196,1),line_char(1196,5))). -user:metta_file_buffer(24,423001478,constant,'car-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1196,6),line_char(1196,14))). -user:metta_file_buffer(25,423001479,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1197,3),line_char(1197,8))). -user:metta_file_buffer(25,423001479,string,"Extracts the first atom of an expression as a tuple",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1197,9),line_char(1197,62))). -user:metta_file_buffer(24,423001479,metta_other,['@desc',"Extracts the first atom of an expression as a tuple"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1197,2),line_char(1197,63))). -user:metta_file_buffer(25,423001480,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1198,3),line_char(1198,10))). -user:metta_file_buffer(27,423001482,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1199,5),line_char(1199,11))). -user:metta_file_buffer(27,423001482,string,"Expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1199,12),line_char(1199,24))). -user:metta_file_buffer(26,423001482,metta_other,['@param',"Expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1199,4),line_char(1199,25))). -user:metta_file_buffer(25,423001482,array,[['@param',"Expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1198,11),line_char(1199,26))). -user:metta_file_buffer(24,423001482,metta_other,['@params',[['@param',"Expression"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1198,2),line_char(1199,27))). -user:metta_file_buffer(25,423001483,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1200,3),line_char(1200,10))). -user:metta_file_buffer(25,423001483,string,"First atom of an expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1200,11),line_char(1200,40))). -user:metta_file_buffer(24,423001483,metta_other,['@return',"First atom of an expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1200,2),line_char(1200,41))). -user:metta_file_buffer(23,423001483,metta_other,['@doc','car-atom',['@desc',"Extracts the first atom of an expression as a tuple"],['@params',[['@param',"Expression"]]],['@return',"First atom of an expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1196,0),line_char(1200,42))). -user:metta_file_buffer(24,424001484,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1201,1),line_char(1201,2))). -user:metta_file_buffer(24,424001484,constant,'car-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1201,3),line_char(1201,11))). -user:metta_file_buffer(25,424001485,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1201,13),line_char(1201,15))). -user:metta_file_buffer(25,424001485,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1201,16),line_char(1201,26))). -user:metta_file_buffer(25,424001485,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1201,27),line_char(1201,31))). -user:metta_file_buffer(24,424001485,metta_other,[->,'Expression','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1201,12),line_char(1201,32))). -user:metta_file_buffer(23,424001485,metta_typedecl,[:,'car-atom',[->,'Expression','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1201,0),line_char(1201,33))). -user:metta_file_buffer(24,425001486,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1202,1),line_char(1202,5))). -user:metta_file_buffer(25,425001487,constant,'car-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1202,7),line_char(1202,15))). -user:metta_file_buffer(25,425001487,variable,_251406,['_atom'=_251406],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1202,16),line_char(1202,21))). -user:metta_file_buffer(24,425001487,indexed(metta_other,['car-atom',_252240]),['car-atom',_252292],['_atom'=_252292],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1202,6),line_char(1202,22))). -user:metta_file_buffer(25,425001488,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1203,3),line_char(1203,7))). -user:metta_file_buffer(26,425001489,constant,'if-decons-expr',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1203,9),line_char(1203,23))). -user:metta_file_buffer(26,425001489,variable,_254888,['_atom'=_254888],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1203,24),line_char(1203,29))). -user:metta_file_buffer(26,425001489,variable,_256172,['_head'=_256172],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1203,30),line_char(1203,35))). -user:metta_file_buffer(26,426001489,variable,_250290,['_head'=_250290],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1204,4),line_char(1204,9))). -user:metta_file_buffer(27,427001490,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1205,5),line_char(1205,10))). -user:metta_file_buffer(28,427001491,constant,'car-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1205,12),line_char(1205,20))). -user:metta_file_buffer(28,427001491,variable,_251800,['_atom'=_251800],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1205,21),line_char(1205,26))). -user:metta_file_buffer(27,427001491,indexed(metta_other,['car-atom',_252634]),['car-atom',_252686],['_atom'=_252686],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1205,11),line_char(1205,27))). -user:metta_file_buffer(27,427001491,string,"car-atom expects a non-empty expression as an argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1205,28),line_char(1205,84))). -user:metta_file_buffer(26,427001491,indexed(metta_other,['Error',['car-atom',_254338],"car-atom expects a non-empty expression as an argument"]),['Error',['car-atom',_254410],"car-atom expects a non-empty expression as an argument"],['_atom'=_254410],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1205,4),line_char(1205,85))). -user:metta_file_buffer(26,428001491,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1205,86),line_char(1205,87))). -user:metta_file_buffer(26,429001491,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1205,87),line_char(1205,88))). -user:metta_file_buffer(26,430001491,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1205,88),line_char(1205,89))). -user:metta_file_buffer(27,431001492,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1207,1),line_char(1207,3))). -user:metta_file_buffer(27,431001492,constant,'cdr-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1207,4),line_char(1207,12))). -user:metta_file_buffer(27,431001492,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1207,13),line_char(1207,18))). -user:metta_file_buffer(26,431001492,metta_other,[iz,'cdr-atom','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1207,0),line_char(1207,19))). -user:metta_file_buffer(27,432001493,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1208,1),line_char(1208,5))). -user:metta_file_buffer(27,432001493,constant,'cdr-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1208,6),line_char(1208,14))). -user:metta_file_buffer(28,432001494,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1209,3),line_char(1209,8))). -user:metta_file_buffer(28,432001494,string,"Extracts the tail of an expression (all except first atom)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1209,9),line_char(1209,69))). -user:metta_file_buffer(27,432001494,metta_other,['@desc',"Extracts the tail of an expression (all except first atom)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1209,2),line_char(1209,70))). -user:metta_file_buffer(28,432001495,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1210,3),line_char(1210,10))). -user:metta_file_buffer(30,432001497,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1211,5),line_char(1211,11))). -user:metta_file_buffer(30,432001497,string,"Expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1211,12),line_char(1211,24))). -user:metta_file_buffer(29,432001497,metta_other,['@param',"Expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1211,4),line_char(1211,25))). -user:metta_file_buffer(28,432001497,array,[['@param',"Expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1210,11),line_char(1211,26))). -user:metta_file_buffer(27,432001497,metta_other,['@params',[['@param',"Expression"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1210,2),line_char(1211,27))). -user:metta_file_buffer(28,432001498,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1212,3),line_char(1212,10))). -user:metta_file_buffer(28,432001498,string,"Tail of an expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1212,11),line_char(1212,34))). -user:metta_file_buffer(27,432001498,metta_other,['@return',"Tail of an expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1212,2),line_char(1212,35))). -user:metta_file_buffer(26,432001498,metta_other,['@doc','cdr-atom',['@desc',"Extracts the tail of an expression (all except first atom)"],['@params',[['@param',"Expression"]]],['@return',"Tail of an expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1208,0),line_char(1212,36))). -user:metta_file_buffer(27,433001499,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1213,1),line_char(1213,2))). -user:metta_file_buffer(27,433001499,constant,'cdr-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1213,3),line_char(1213,11))). -user:metta_file_buffer(28,433001500,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1213,13),line_char(1213,15))). -user:metta_file_buffer(28,433001500,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1213,16),line_char(1213,26))). -user:metta_file_buffer(28,433001500,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1213,27),line_char(1213,37))). -user:metta_file_buffer(27,433001500,metta_other,[->,'Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1213,12),line_char(1213,38))). -user:metta_file_buffer(26,433001500,metta_typedecl,[:,'cdr-atom',[->,'Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1213,0),line_char(1213,39))). -user:metta_file_buffer(27,434001501,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1214,1),line_char(1214,2))). -user:metta_file_buffer(28,434001502,constant,'cdr-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1214,4),line_char(1214,12))). -user:metta_file_buffer(28,434001502,variable,_252774,['_atom'=_252774],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1214,13),line_char(1214,18))). -user:metta_file_buffer(27,434001502,indexed(metta_other,['cdr-atom',_253608]),['cdr-atom',_253660],['_atom'=_253660],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1214,3),line_char(1214,19))). -user:metta_file_buffer(28,434001503,constant,eval,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1215,3),line_char(1215,7))). -user:metta_file_buffer(29,434001504,constant,'if-decons-expr',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1215,9),line_char(1215,23))). -user:metta_file_buffer(29,434001504,variable,_256256,['_atom'=_256256],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1215,24),line_char(1215,29))). -user:metta_file_buffer(29,435001504,variable,_251394,['_tail'=_251394],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1215,33),line_char(1215,38))). -user:metta_file_buffer(29,436001504,variable,_251402,['_tail'=_251402],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1216,4),line_char(1216,9))). -user:metta_file_buffer(30,437001505,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1217,5),line_char(1217,10))). -user:metta_file_buffer(31,437001506,constant,'cdr-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1217,12),line_char(1217,20))). -user:metta_file_buffer(31,437001506,variable,_252912,['_atom'=_252912],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1217,21),line_char(1217,26))). -user:metta_file_buffer(30,437001506,indexed(metta_other,['cdr-atom',_253746]),['cdr-atom',_253798],['_atom'=_253798],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1217,11),line_char(1217,27))). -user:metta_file_buffer(30,437001506,string,"cdr-atom expects a non-empty expression as an argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1217,28),line_char(1217,84))). -user:metta_file_buffer(29,437001506,indexed(metta_other,['Error',['cdr-atom',_255450],"cdr-atom expects a non-empty expression as an argument"]),['Error',['cdr-atom',_255522],"cdr-atom expects a non-empty expression as an argument"],['_atom'=_255522],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1217,4),line_char(1217,85))). -user:metta_file_buffer(29,438001506,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1217,86),line_char(1217,87))). -user:metta_file_buffer(29,439001506,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1217,87),line_char(1217,88))). -user:metta_file_buffer(29,440001506,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1217,88),line_char(1217,89))). -user:metta_file_buffer(30,441001507,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1219,1),line_char(1219,3))). -user:metta_file_buffer(30,441001507,constant,quote,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1219,4),line_char(1219,9))). -user:metta_file_buffer(30,441001507,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1219,10),line_char(1219,15))). -user:metta_file_buffer(29,441001507,metta_other,[iz,quote,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1219,0),line_char(1219,16))). -user:metta_file_buffer(30,442001508,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1220,1),line_char(1220,5))). -user:metta_file_buffer(30,442001508,constant,quote,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1220,6),line_char(1220,11))). -user:metta_file_buffer(31,442001509,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1221,3),line_char(1221,8))). -user:metta_file_buffer(31,442001509,string,"Prevents atom from being reduced",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1221,9),line_char(1221,43))). -user:metta_file_buffer(30,442001509,metta_other,['@desc',"Prevents atom from being reduced"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1221,2),line_char(1221,44))). -user:metta_file_buffer(31,442001510,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1222,3),line_char(1222,10))). -user:metta_file_buffer(33,442001512,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1223,5),line_char(1223,11))). -user:metta_file_buffer(33,442001512,string,"Atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1223,12),line_char(1223,18))). -user:metta_file_buffer(32,442001512,metta_other,['@param',"Atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1223,4),line_char(1223,19))). -user:metta_file_buffer(31,442001512,array,[['@param',"Atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1222,11),line_char(1223,20))). -user:metta_file_buffer(30,442001512,metta_other,['@params',[['@param',"Atom"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1222,2),line_char(1223,21))). -user:metta_file_buffer(31,442001513,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1224,3),line_char(1224,10))). -user:metta_file_buffer(31,442001513,string,"Quoted atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1224,11),line_char(1224,24))). -user:metta_file_buffer(30,442001513,metta_other,['@return',"Quoted atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1224,2),line_char(1224,25))). -user:metta_file_buffer(29,442001513,metta_other,['@doc',quote,['@desc',"Prevents atom from being reduced"],['@params',[['@param',"Atom"]]],['@return',"Quoted atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1220,0),line_char(1224,26))). -user:metta_file_buffer(30,443001514,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1225,1),line_char(1225,2))). -user:metta_file_buffer(30,443001514,constant,quote,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1225,3),line_char(1225,8))). -user:metta_file_buffer(31,443001515,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1225,10),line_char(1225,12))). -user:metta_file_buffer(31,443001515,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1225,13),line_char(1225,17))). -user:metta_file_buffer(31,443001515,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1225,18),line_char(1225,22))). -user:metta_file_buffer(30,443001515,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1225,9),line_char(1225,23))). -user:metta_file_buffer(29,443001515,metta_typedecl,[:,quote,[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1225,0),line_char(1225,24))). -user:metta_file_buffer(30,444001516,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1226,1),line_char(1226,2))). -user:metta_file_buffer(31,444001517,constant,quote,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1226,4),line_char(1226,9))). -user:metta_file_buffer(31,444001517,variable,_253924,['_atom'=_253924],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1226,10),line_char(1226,15))). -user:metta_file_buffer(30,444001517,indexed(metta_other,[quote,_254758]),[quote,_254810],['_atom'=_254810],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1226,3),line_char(1226,16))). -user:metta_file_buffer(30,444001517,constant,'NotReducible',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1226,17),line_char(1226,29))). -user:metta_file_buffer(29,444001517,indexed(metta_defun,[quote,_256030]),[=,[quote,_256102],'NotReducible'],['_atom'=_256102],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1226,0),line_char(1226,30))). -user:metta_file_buffer(30,445001518,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1228,1),line_char(1228,3))). -user:metta_file_buffer(30,445001518,constant,unquote,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1228,4),line_char(1228,11))). -user:metta_file_buffer(30,445001518,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1228,12),line_char(1228,17))). -user:metta_file_buffer(29,445001518,metta_other,[iz,unquote,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1228,0),line_char(1228,18))). -user:metta_file_buffer(30,446001519,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1229,1),line_char(1229,5))). -user:metta_file_buffer(30,446001519,constant,unquote,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1229,6),line_char(1229,13))). -user:metta_file_buffer(31,446001520,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1230,3),line_char(1230,8))). -user:metta_file_buffer(31,446001520,string,"Unquotes quoted atom, e.g. (unquote (quote $x)) returns $x",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1230,9),line_char(1230,69))). -user:metta_file_buffer(30,446001520,metta_other,['@desc',"Unquotes quoted atom, e.g. (unquote (quote $x)) returns $x"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1230,2),line_char(1230,70))). -user:metta_file_buffer(31,446001521,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1231,3),line_char(1231,10))). -user:metta_file_buffer(33,446001523,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1232,5),line_char(1232,11))). -user:metta_file_buffer(33,446001523,string,"Quoted atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1232,12),line_char(1232,25))). -user:metta_file_buffer(32,446001523,metta_other,['@param',"Quoted atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1232,4),line_char(1232,26))). -user:metta_file_buffer(31,446001523,array,[['@param',"Quoted atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1231,11),line_char(1232,27))). -user:metta_file_buffer(30,446001523,metta_other,['@params',[['@param',"Quoted atom"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1231,2),line_char(1232,28))). -user:metta_file_buffer(31,446001524,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1233,3),line_char(1233,10))). -user:metta_file_buffer(31,446001524,string,"Unquoted atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1233,11),line_char(1233,26))). -user:metta_file_buffer(30,446001524,metta_other,['@return',"Unquoted atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1233,2),line_char(1233,27))). -user:metta_file_buffer(29,446001524,metta_other,['@doc',unquote,['@desc',"Unquotes quoted atom, e.g. (unquote (quote $x)) returns $x"],['@params',[['@param',"Quoted atom"]]],['@return',"Unquoted atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1229,0),line_char(1233,28))). -user:metta_file_buffer(30,447001525,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1234,1),line_char(1234,2))). -user:metta_file_buffer(30,447001525,constant,unquote,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1234,3),line_char(1234,10))). -user:metta_file_buffer(31,447001526,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1234,12),line_char(1234,14))). -user:metta_file_buffer(31,447001526,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1234,15),line_char(1234,26))). -user:metta_file_buffer(31,447001526,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1234,27),line_char(1234,38))). -user:metta_file_buffer(30,447001526,metta_other,[->,'%Undefined%','%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1234,11),line_char(1234,39))). -user:metta_file_buffer(29,447001526,metta_typedecl,[:,unquote,[->,'%Undefined%','%Undefined%']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1234,0),line_char(1234,40))). -user:metta_file_buffer(30,448001527,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1235,1),line_char(1235,2))). -user:metta_file_buffer(31,448001528,constant,unquote,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1235,4),line_char(1235,11))). -user:metta_file_buffer(32,448001529,constant,quote,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1235,13),line_char(1235,18))). -user:metta_file_buffer(32,448001529,variable,_258160,['_atom'=_258160],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1235,19),line_char(1235,24))). -user:metta_file_buffer(31,448001529,indexed(metta_other,[quote,_258994]),[quote,_259046],['_atom'=_259046],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1235,12),line_char(1235,25))). -user:metta_file_buffer(30,448001529,indexed(metta_other,[unquote,[quote,_259584]]),[unquote,[quote,_259648]],['_atom'=_259648],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1235,3),line_char(1235,26))). -user:metta_file_buffer(30,448001529,variable,_260628,['_atom'=_260628],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1235,27),line_char(1235,32))). -user:metta_file_buffer(29,448001529,indexed(metta_defun,[unquote,[quote,_261500]]),[=,[unquote,[quote,_261594]],_261594],['_atom'=_261594],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1235,0),line_char(1235,33))). -user:metta_file_buffer(29,449001529,indexed(metta_comment,"; TODO: there is no way to define operation which consumes any number of"),'$COMMENT'("; TODO: there is no way to define operation which consumes any number of",1237,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1237,0),line_char(1237,72))). -user:metta_file_buffer(29,449001529,indexed(metta_comment,"; arguments and returns unit"),'$COMMENT'("; arguments and returns unit",1238,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1238,0),line_char(1238,29))). -user:metta_file_buffer(30,449001530,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1239,1),line_char(1239,3))). -user:metta_file_buffer(30,449001530,constant,nop,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1239,4),line_char(1239,7))). -user:metta_file_buffer(30,449001530,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1239,8),line_char(1239,13))). -user:metta_file_buffer(29,449001530,metta_other,[iz,nop,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1239,0),line_char(1239,14))). -user:metta_file_buffer(30,450001531,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1240,1),line_char(1240,5))). -user:metta_file_buffer(30,450001531,constant,nop,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1240,6),line_char(1240,9))). -user:metta_file_buffer(31,450001532,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1241,3),line_char(1241,8))). -user:metta_file_buffer(31,450001532,string,"Outputs unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1241,9),line_char(1241,28))). -user:metta_file_buffer(30,450001532,metta_other,['@desc',"Outputs unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1241,2),line_char(1241,29))). -user:metta_file_buffer(31,450001533,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1242,3),line_char(1242,10))). -user:metta_file_buffer(31,450001534,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1242,11),line_char(1242,13))). -user:metta_file_buffer(30,450001534,metta_other,['@params',[]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1242,2),line_char(1242,14))). -user:metta_file_buffer(31,450001535,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1243,3),line_char(1243,10))). -user:metta_file_buffer(31,450001535,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1243,11),line_char(1243,22))). -user:metta_file_buffer(30,450001535,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1243,2),line_char(1243,23))). -user:metta_file_buffer(29,450001535,metta_other,['@doc',nop,['@desc',"Outputs unit atom"],['@params',[]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1240,0),line_char(1243,24))). -user:metta_file_buffer(30,451001536,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1244,1),line_char(1244,2))). -user:metta_file_buffer(30,451001536,constant,nop,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1244,3),line_char(1244,6))). -user:metta_file_buffer(31,451001537,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1244,8),line_char(1244,10))). -user:metta_file_buffer(31,451001537,constant,'EmptyType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1244,11),line_char(1244,20))). -user:metta_file_buffer(30,451001537,metta_other,[->,'EmptyType'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1244,7),line_char(1244,21))). -user:metta_file_buffer(29,451001537,metta_typedecl,[:,nop,[->,'EmptyType']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1244,0),line_char(1244,22))). -user:metta_file_buffer(30,452001538,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1245,1),line_char(1245,5))). -user:metta_file_buffer(31,452001539,constant,nop,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1245,7),line_char(1245,10))). -user:metta_file_buffer(30,452001539,metta_other,[nop],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1245,6),line_char(1245,11))). -user:metta_file_buffer(30,452001540,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1245,12),line_char(1245,14))). -user:metta_file_buffer(29,452001540,metta_other,['ALT=',[nop],[]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1245,0),line_char(1245,15))). -user:metta_file_buffer(30,453001541,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1247,1),line_char(1247,3))). -user:metta_file_buffer(30,453001541,constant,nop,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1247,4),line_char(1247,7))). -user:metta_file_buffer(30,453001541,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1247,8),line_char(1247,13))). -user:metta_file_buffer(29,453001541,metta_other,[iz,nop,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1247,0),line_char(1247,14))). -user:metta_file_buffer(30,454001542,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1248,1),line_char(1248,5))). -user:metta_file_buffer(30,454001542,constant,nop,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1248,6),line_char(1248,9))). -user:metta_file_buffer(31,454001543,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1249,3),line_char(1249,8))). -user:metta_file_buffer(31,454001543,string,"Outputs unit atom for any input",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1249,9),line_char(1249,42))). -user:metta_file_buffer(30,454001543,metta_other,['@desc',"Outputs unit atom for any input"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1249,2),line_char(1249,43))). -user:metta_file_buffer(31,454001544,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1250,3),line_char(1250,10))). -user:metta_file_buffer(33,454001546,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1251,5),line_char(1251,11))). -user:metta_file_buffer(33,454001546,string,"Anything",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1251,12),line_char(1251,22))). -user:metta_file_buffer(32,454001546,metta_other,['@param',"Anything"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1251,4),line_char(1251,23))). -user:metta_file_buffer(31,454001546,array,[['@param',"Anything"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1250,11),line_char(1251,24))). -user:metta_file_buffer(30,454001546,metta_other,['@params',[['@param',"Anything"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1250,2),line_char(1251,25))). -user:metta_file_buffer(31,454001547,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1252,3),line_char(1252,10))). -user:metta_file_buffer(31,454001547,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1252,11),line_char(1252,22))). -user:metta_file_buffer(30,454001547,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1252,2),line_char(1252,23))). -user:metta_file_buffer(29,454001547,metta_other,['@doc',nop,['@desc',"Outputs unit atom for any input"],['@params',[['@param',"Anything"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1248,0),line_char(1252,24))). -user:metta_file_buffer(30,455001548,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1253,1),line_char(1253,2))). -user:metta_file_buffer(30,455001548,constant,nop,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1253,3),line_char(1253,6))). -user:metta_file_buffer(31,455001549,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1253,8),line_char(1253,10))). -user:metta_file_buffer(31,455001549,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1253,11),line_char(1253,15))). -user:metta_file_buffer(32,455001550,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1253,17),line_char(1253,19))). -user:metta_file_buffer(31,455001550,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1253,16),line_char(1253,20))). -user:metta_file_buffer(30,455001550,metta_other,[->,'Atom',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1253,7),line_char(1253,21))). -user:metta_file_buffer(29,455001550,metta_typedecl,[:,nop,[->,'Atom',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1253,0),line_char(1253,22))). -user:metta_file_buffer(30,456001551,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1254,1),line_char(1254,5))). -user:metta_file_buffer(31,456001552,constant,nop,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1254,7),line_char(1254,10))). -user:metta_file_buffer(31,456001552,variable,_257824,['_x'=_257824],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1254,11),line_char(1254,13))). -user:metta_file_buffer(30,456001552,indexed(metta_other,[nop,_258658]),[nop,_258710],['_x'=_258710],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1254,6),line_char(1254,14))). -user:metta_file_buffer(30,456001553,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1254,15),line_char(1254,17))). -user:metta_file_buffer(29,456001553,indexed(metta_other,['ALT=',[nop,_259902],[]]),['ALT=',[nop,_259974],[]],['_x'=_259974],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1254,0),line_char(1254,18))). -user:metta_file_buffer(30,457001554,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1256,1),line_char(1256,3))). -user:metta_file_buffer(30,457001554,constant,empty,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1256,4),line_char(1256,9))). -user:metta_file_buffer(30,457001554,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1256,10),line_char(1256,15))). -user:metta_file_buffer(29,457001554,metta_other,[iz,empty,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1256,0),line_char(1256,16))). -user:metta_file_buffer(29,458001554,indexed(metta_comment,"; TODO: can be replaced by Empty atom and removed, kept for compatibility"),'$COMMENT'("; TODO: can be replaced by Empty atom and removed, kept for compatibility",1257,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1257,0),line_char(1257,73))). -user:metta_file_buffer(30,458001555,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1258,1),line_char(1258,5))). -user:metta_file_buffer(30,458001555,constant,empty,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1258,6),line_char(1258,11))). -user:metta_file_buffer(31,458001556,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1259,3),line_char(1259,8))). -user:metta_file_buffer(31,458001556,string,"Cuts evaluation of the non-deterministic branch and removes it from the result",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1259,9),line_char(1259,89))). -user:metta_file_buffer(30,458001556,metta_other,['@desc',"Cuts evaluation of the non-deterministic branch and removes it from the result"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1259,2),line_char(1259,90))). -user:metta_file_buffer(31,458001557,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1260,3),line_char(1260,10))). -user:metta_file_buffer(31,458001558,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1260,11),line_char(1260,13))). -user:metta_file_buffer(30,458001558,metta_other,['@params',[]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1260,2),line_char(1260,14))). -user:metta_file_buffer(31,458001559,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1261,3),line_char(1261,10))). -user:metta_file_buffer(31,458001559,string,"Nothing",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1261,11),line_char(1261,20))). -user:metta_file_buffer(30,458001559,metta_other,['@return',"Nothing"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1261,2),line_char(1261,21))). -user:metta_file_buffer(29,458001559,metta_other,['@doc',empty,['@desc',"Cuts evaluation of the non-deterministic branch and removes it from the result"],['@params',[]],['@return',"Nothing"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1258,0),line_char(1261,22))). -user:metta_file_buffer(30,459001560,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1262,1),line_char(1262,2))). -user:metta_file_buffer(30,459001560,constant,empty,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1262,3),line_char(1262,8))). -user:metta_file_buffer(31,459001561,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1262,10),line_char(1262,12))). -user:metta_file_buffer(31,459001561,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1262,13),line_char(1262,24))). -user:metta_file_buffer(30,459001561,metta_other,[->,'%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1262,9),line_char(1262,25))). -user:metta_file_buffer(29,459001561,metta_typedecl,[:,empty,[->,'%Undefined%']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1262,0),line_char(1262,26))). -user:metta_file_buffer(30,460001562,constant,'ALT=',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1263,1),line_char(1263,5))). -user:metta_file_buffer(31,460001563,constant,empty,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1263,7),line_char(1263,12))). -user:metta_file_buffer(30,460001563,metta_other,[empty],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1263,6),line_char(1263,13))). -user:metta_file_buffer(31,460001564,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1263,15),line_char(1263,18))). -user:metta_file_buffer(31,460001564,constant,a,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1263,19),line_char(1263,20))). -user:metta_file_buffer(31,460001564,constant,b,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1263,21),line_char(1263,22))). -user:metta_file_buffer(31,460001564,constant,'never-happens',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1263,23),line_char(1263,36))). -user:metta_file_buffer(30,460001564,metta_other,[let,a,b,'never-happens'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1263,14),line_char(1263,37))). -user:metta_file_buffer(29,460001564,metta_other,['ALT=',[empty],[let,a,b,'never-happens']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1263,0),line_char(1263,38))). -user:metta_file_buffer(29,461001564,indexed(metta_comment,";For testing"),'$COMMENT'(";For testing",1264,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1264,0),line_char(1264,12))). -user:metta_file_buffer(29,461001564,indexed(metta_comment,";(= (empty) Empty)"),'$COMMENT'(";(= (empty) Empty)",1265,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1265,0),line_char(1265,18))). -user:metta_file_buffer(29,461001564,indexed(metta_comment,";(= (empty-rust1) (let a b never-happens))"),'$COMMENT'(";(= (empty-rust1) (let a b never-happens))",1267,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1267,0),line_char(1267,42))). -user:metta_file_buffer(29,461001564,indexed(metta_comment,"; TODO: MINIMAL added for compatibility, remove after migration"),'$COMMENT'("; TODO: MINIMAL added for compatibility, remove after migration",1268,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1268,0),line_char(1268,63))). -user:metta_file_buffer(29,461001564,indexed(metta_comment,";(= (empty-minimal) Empty)"),'$COMMENT'(";(= (empty-minimal) Empty)",1269,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1269,0),line_char(1269,26))). -user:metta_file_buffer(30,461001565,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1271,1),line_char(1271,3))). -user:metta_file_buffer(30,461001565,constant,unique,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1271,4),line_char(1271,10))). -user:metta_file_buffer(30,461001565,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1271,11),line_char(1271,16))). -user:metta_file_buffer(29,461001565,metta_other,[iz,unique,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1271,0),line_char(1271,17))). -user:metta_file_buffer(30,462001566,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1272,1),line_char(1272,5))). -user:metta_file_buffer(30,462001566,constant,unique,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1272,6),line_char(1272,12))). -user:metta_file_buffer(31,462001567,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1273,3),line_char(1273,8))). -user:metta_file_buffer(31,462001567,string,"Function takes non-deterministic input (first argument) and returns only unique entities. E.g. (unique (superpose (a b c d d))) -> [a, b, c, d]",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1273,9),line_char(1273,154))). -user:metta_file_buffer(30,462001567,metta_other,['@desc',"Function takes non-deterministic input (first argument) and returns only unique entities. E.g. (unique (superpose (a b c d d))) -> [a, b, c, d]"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1273,2),line_char(1273,155))). -user:metta_file_buffer(31,462001568,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1274,3),line_char(1274,10))). -user:metta_file_buffer(33,462001570,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1275,5),line_char(1275,11))). -user:metta_file_buffer(33,462001570,string,"Non-deterministic set of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1275,12),line_char(1275,45))). -user:metta_file_buffer(32,462001570,metta_other,['@param',"Non-deterministic set of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1275,4),line_char(1275,46))). -user:metta_file_buffer(31,462001570,array,[['@param',"Non-deterministic set of values"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1274,11),line_char(1275,47))). -user:metta_file_buffer(30,462001570,metta_other,['@params',[['@param',"Non-deterministic set of values"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1274,2),line_char(1275,48))). -user:metta_file_buffer(31,462001571,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1276,3),line_char(1276,10))). -user:metta_file_buffer(31,462001571,string,"Unique non-deterministic values from input set",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1276,11),line_char(1276,59))). -user:metta_file_buffer(30,462001571,metta_other,['@return',"Unique non-deterministic values from input set"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1276,2),line_char(1276,60))). -user:metta_file_buffer(29,462001571,metta_other,['@doc',unique,['@desc',"Function takes non-deterministic input (first argument) and returns only unique entities. E.g. (unique (superpose (a b c d d))) -> [a, b, c, d]"],['@params',[['@param',"Non-deterministic set of values"]]],['@return',"Unique non-deterministic values from input set"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1272,0),line_char(1276,61))). -user:metta_file_buffer(30,463001572,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1277,1),line_char(1277,2))). -user:metta_file_buffer(30,463001572,constant,unique,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1277,3),line_char(1277,9))). -user:metta_file_buffer(31,463001573,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1277,11),line_char(1277,13))). -user:metta_file_buffer(31,463001573,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1277,14),line_char(1277,18))). -user:metta_file_buffer(31,463001573,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1277,19),line_char(1277,23))). -user:metta_file_buffer(30,463001573,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1277,10),line_char(1277,24))). -user:metta_file_buffer(29,463001573,metta_typedecl,[:,unique,[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1277,0),line_char(1277,25))). -user:metta_file_buffer(30,464001574,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1279,1),line_char(1279,3))). -user:metta_file_buffer(30,464001574,constant,union,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1279,4),line_char(1279,9))). -user:metta_file_buffer(30,464001574,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1279,10),line_char(1279,15))). -user:metta_file_buffer(29,464001574,metta_other,[iz,union,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1279,0),line_char(1279,16))). -user:metta_file_buffer(30,465001575,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1280,1),line_char(1280,5))). -user:metta_file_buffer(30,465001575,constant,union,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1280,6),line_char(1280,11))). -user:metta_file_buffer(31,465001576,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1281,3),line_char(1281,8))). -user:metta_file_buffer(31,465001576,string,"Function takes two non-deterministic inputs (first and second argument) and returns their union. E.g. (union (superpose (a b b c)) (superpose (b c c d))) -> [a, b, b, c, b, c, c, d]",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1281,9),line_char(1281,192))). -user:metta_file_buffer(30,465001576,metta_other,['@desc',"Function takes two non-deterministic inputs (first and second argument) and returns their union. E.g. (union (superpose (a b b c)) (superpose (b c c d))) -> [a, b, b, c, b, c, c, d]"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1281,2),line_char(1281,193))). -user:metta_file_buffer(31,465001577,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1282,3),line_char(1282,10))). -user:metta_file_buffer(33,465001579,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1283,5),line_char(1283,11))). -user:metta_file_buffer(33,465001579,string,"Non-deterministic set of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1283,12),line_char(1283,45))). -user:metta_file_buffer(32,465001579,metta_other,['@param',"Non-deterministic set of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1283,4),line_char(1283,46))). -user:metta_file_buffer(33,465001580,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1284,5),line_char(1284,11))). -user:metta_file_buffer(33,465001580,string,"Another non-deterministic set of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1284,12),line_char(1284,53))). -user:metta_file_buffer(32,465001580,metta_other,['@param',"Another non-deterministic set of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1284,4),line_char(1284,54))). -user:metta_file_buffer(31,465001580,array,[['@param',"Non-deterministic set of values"],['@param',"Another non-deterministic set of values"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1282,11),line_char(1284,55))). -user:metta_file_buffer(30,465001580,metta_other,['@params',[['@param',"Non-deterministic set of values"],['@param',"Another non-deterministic set of values"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1282,2),line_char(1284,56))). -user:metta_file_buffer(31,465001581,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1285,3),line_char(1285,10))). -user:metta_file_buffer(31,465001581,string,"Non-deterministic Union of sets",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1285,11),line_char(1285,44))). -user:metta_file_buffer(30,465001581,metta_other,['@return',"Non-deterministic Union of sets"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1285,2),line_char(1285,45))). -user:metta_file_buffer(29,465001581,metta_other,['@doc',union,['@desc',"Function takes two non-deterministic inputs (first and second argument) and returns their union. E.g. (union (superpose (a b b c)) (superpose (b c c d))) -> [a, b, b, c, b, c, c, d]"],['@params',[['@param',"Non-deterministic set of values"],['@param',"Another non-deterministic set of values"]]],['@return',"Non-deterministic Union of sets"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1280,0),line_char(1285,46))). -user:metta_file_buffer(30,466001582,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1286,1),line_char(1286,2))). -user:metta_file_buffer(30,466001582,constant,union,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1286,3),line_char(1286,8))). -user:metta_file_buffer(31,466001583,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1286,10),line_char(1286,12))). -user:metta_file_buffer(31,466001583,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1286,13),line_char(1286,17))). -user:metta_file_buffer(31,466001583,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1286,18),line_char(1286,22))). -user:metta_file_buffer(31,466001583,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1286,23),line_char(1286,27))). -user:metta_file_buffer(30,466001583,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1286,9),line_char(1286,28))). -user:metta_file_buffer(29,466001583,metta_typedecl,[:,union,[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1286,0),line_char(1286,29))). -user:metta_file_buffer(30,467001584,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1288,1),line_char(1288,3))). -user:metta_file_buffer(30,467001584,constant,intersection,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1288,4),line_char(1288,16))). -user:metta_file_buffer(30,467001584,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1288,17),line_char(1288,22))). -user:metta_file_buffer(29,467001584,metta_other,[iz,intersection,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1288,0),line_char(1288,23))). -user:metta_file_buffer(30,468001585,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1289,1),line_char(1289,5))). -user:metta_file_buffer(30,468001585,constant,intersection,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1289,6),line_char(1289,18))). -user:metta_file_buffer(31,468001586,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1290,3),line_char(1290,8))). -user:metta_file_buffer(31,468001586,string,"Function takes two non-deterministic inputs (first and second argument) and returns their intersection. E.g. (intersection (superpose (a b c c)) (superpose (b c c c d))) -> [b, c, c]",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1290,9),line_char(1290,193))). -user:metta_file_buffer(30,468001586,metta_other,['@desc',"Function takes two non-deterministic inputs (first and second argument) and returns their intersection. E.g. (intersection (superpose (a b c c)) (superpose (b c c c d))) -> [b, c, c]"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1290,2),line_char(1290,194))). -user:metta_file_buffer(31,468001587,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1291,3),line_char(1291,10))). -user:metta_file_buffer(33,468001589,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1292,5),line_char(1292,11))). -user:metta_file_buffer(33,468001589,string,"Non-deterministic set of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1292,12),line_char(1292,45))). -user:metta_file_buffer(32,468001589,metta_other,['@param',"Non-deterministic set of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1292,4),line_char(1292,46))). -user:metta_file_buffer(33,468001590,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1293,5),line_char(1293,11))). -user:metta_file_buffer(33,468001590,string,"Another non-deterministic set of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1293,12),line_char(1293,53))). -user:metta_file_buffer(32,468001590,metta_other,['@param',"Another non-deterministic set of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1293,4),line_char(1293,54))). -user:metta_file_buffer(31,468001590,array,[['@param',"Non-deterministic set of values"],['@param',"Another non-deterministic set of values"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1291,11),line_char(1293,55))). -user:metta_file_buffer(30,468001590,metta_other,['@params',[['@param',"Non-deterministic set of values"],['@param',"Another non-deterministic set of values"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1291,2),line_char(1293,56))). -user:metta_file_buffer(31,468001591,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1294,3),line_char(1294,10))). -user:metta_file_buffer(31,468001591,string,"Non-deterministic Intersection of sets",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1294,11),line_char(1294,51))). -user:metta_file_buffer(30,468001591,metta_other,['@return',"Non-deterministic Intersection of sets"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1294,2),line_char(1294,52))). -user:metta_file_buffer(29,468001591,metta_other,['@doc',intersection,['@desc',"Function takes two non-deterministic inputs (first and second argument) and returns their intersection. E.g. (intersection (superpose (a b c c)) (superpose (b c c c d))) -> [b, c, c]"],['@params',[['@param',"Non-deterministic set of values"],['@param',"Another non-deterministic set of values"]]],['@return',"Non-deterministic Intersection of sets"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1289,0),line_char(1294,53))). -user:metta_file_buffer(30,469001592,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1295,1),line_char(1295,2))). -user:metta_file_buffer(30,469001592,constant,intersection,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1295,3),line_char(1295,15))). -user:metta_file_buffer(31,469001593,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1295,17),line_char(1295,19))). -user:metta_file_buffer(31,469001593,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1295,20),line_char(1295,24))). -user:metta_file_buffer(31,469001593,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1295,25),line_char(1295,29))). -user:metta_file_buffer(31,469001593,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1295,30),line_char(1295,34))). -user:metta_file_buffer(30,469001593,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1295,16),line_char(1295,35))). -user:metta_file_buffer(29,469001593,metta_typedecl,[:,intersection,[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1295,0),line_char(1295,36))). -user:metta_file_buffer(30,470001594,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1297,1),line_char(1297,3))). -user:metta_file_buffer(30,470001594,constant,subtraction,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1297,4),line_char(1297,15))). -user:metta_file_buffer(30,470001594,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1297,16),line_char(1297,21))). -user:metta_file_buffer(29,470001594,metta_other,[iz,subtraction,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1297,0),line_char(1297,22))). -user:metta_file_buffer(30,471001595,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1298,1),line_char(1298,5))). -user:metta_file_buffer(30,471001595,constant,subtraction,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1298,6),line_char(1298,17))). -user:metta_file_buffer(31,471001596,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1299,3),line_char(1299,8))). -user:metta_file_buffer(31,471001596,string,"Function takes two non-deterministic inputs (first and second argument) and returns their subtraction. E.g. !(subtraction (superpose (a b b c)) (superpose (b c c d))) -> [a, b]",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1299,9),line_char(1299,187))). -user:metta_file_buffer(30,471001596,metta_other,['@desc',"Function takes two non-deterministic inputs (first and second argument) and returns their subtraction. E.g. !(subtraction (superpose (a b b c)) (superpose (b c c d))) -> [a, b]"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1299,2),line_char(1299,188))). -user:metta_file_buffer(31,471001597,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1300,3),line_char(1300,10))). -user:metta_file_buffer(33,471001599,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1301,5),line_char(1301,11))). -user:metta_file_buffer(33,471001599,string,"Non-deterministic set of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1301,12),line_char(1301,45))). -user:metta_file_buffer(32,471001599,metta_other,['@param',"Non-deterministic set of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1301,4),line_char(1301,46))). -user:metta_file_buffer(33,471001600,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1302,5),line_char(1302,11))). -user:metta_file_buffer(33,471001600,string,"Another non-deterministic set of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1302,12),line_char(1302,53))). -user:metta_file_buffer(32,471001600,metta_other,['@param',"Another non-deterministic set of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1302,4),line_char(1302,54))). -user:metta_file_buffer(31,471001600,array,[['@param',"Non-deterministic set of values"],['@param',"Another non-deterministic set of values"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1300,11),line_char(1302,55))). -user:metta_file_buffer(30,471001600,metta_other,['@params',[['@param',"Non-deterministic set of values"],['@param',"Another non-deterministic set of values"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1300,2),line_char(1302,56))). -user:metta_file_buffer(31,471001601,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1303,3),line_char(1303,10))). -user:metta_file_buffer(31,471001601,string,"Non-deterministic Subtraction of sets",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1303,11),line_char(1303,50))). -user:metta_file_buffer(30,471001601,metta_other,['@return',"Non-deterministic Subtraction of sets"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1303,2),line_char(1303,51))). -user:metta_file_buffer(29,471001601,metta_other,['@doc',subtraction,['@desc',"Function takes two non-deterministic inputs (first and second argument) and returns their subtraction. E.g. !(subtraction (superpose (a b b c)) (superpose (b c c d))) -> [a, b]"],['@params',[['@param',"Non-deterministic set of values"],['@param',"Another non-deterministic set of values"]]],['@return',"Non-deterministic Subtraction of sets"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1298,0),line_char(1303,52))). -user:metta_file_buffer(30,472001602,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1304,1),line_char(1304,2))). -user:metta_file_buffer(30,472001602,constant,subtraction,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1304,3),line_char(1304,14))). -user:metta_file_buffer(31,472001603,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1304,16),line_char(1304,18))). -user:metta_file_buffer(31,472001603,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1304,19),line_char(1304,23))). -user:metta_file_buffer(31,472001603,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1304,24),line_char(1304,28))). -user:metta_file_buffer(31,472001603,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1304,29),line_char(1304,33))). -user:metta_file_buffer(30,472001603,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1304,15),line_char(1304,34))). -user:metta_file_buffer(29,472001603,metta_typedecl,[:,subtraction,[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1304,0),line_char(1304,35))). -user:metta_file_buffer(29,473001603,indexed(metta_comment,";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"),'$COMMENT'(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",1306,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1306,0),line_char(1306,36))). -user:metta_file_buffer(29,473001603,indexed(metta_comment,"; Documentation formatting functions"),'$COMMENT'("; Documentation formatting functions",1307,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1307,0),line_char(1307,36))). -user:metta_file_buffer(29,473001603,indexed(metta_comment,";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"),'$COMMENT'(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",1308,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1308,0),line_char(1308,36))). -user:metta_file_buffer(30,473001604,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1310,1),line_char(1310,3))). -user:metta_file_buffer(30,473001604,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1310,4),line_char(1310,8))). -user:metta_file_buffer(30,473001604,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1310,9),line_char(1310,14))). -user:metta_file_buffer(29,473001604,metta_other,[iz,'@doc','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1310,0),line_char(1310,15))). -user:metta_file_buffer(30,474001605,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1311,1),line_char(1311,5))). -user:metta_file_buffer(30,474001605,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1311,6),line_char(1311,10))). -user:metta_file_buffer(31,474001606,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1312,3),line_char(1312,8))). -user:metta_file_buffer(31,474001606,string,"Used for documentation purposes. Function documentation starts with @doc",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1312,9),line_char(1312,83))). -user:metta_file_buffer(30,474001606,metta_other,['@desc',"Used for documentation purposes. Function documentation starts with @doc"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1312,2),line_char(1312,84))). -user:metta_file_buffer(31,474001607,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1313,3),line_char(1313,10))). -user:metta_file_buffer(33,474001609,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1314,5),line_char(1314,11))). -user:metta_file_buffer(33,474001609,string,"Function name",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1314,12),line_char(1314,27))). -user:metta_file_buffer(32,474001609,metta_other,['@param',"Function name"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1314,4),line_char(1314,28))). -user:metta_file_buffer(33,474001610,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1315,5),line_char(1315,11))). -user:metta_file_buffer(33,474001610,string,"Function description. Starts with @desc",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1315,12),line_char(1315,53))). -user:metta_file_buffer(32,474001610,metta_other,['@param',"Function description. Starts with @desc"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1315,4),line_char(1315,54))). -user:metta_file_buffer(33,474001611,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1316,5),line_char(1316,11))). -user:metta_file_buffer(33,474001611,string,"(Optional) parameters description starting with @params which should contain one or more @param symbols",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1316,12),line_char(1316,117))). -user:metta_file_buffer(32,474001611,metta_other,['@param',"(Optional) parameters description starting with @params which should contain one or more @param symbols"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1316,4),line_char(1316,118))). -user:metta_file_buffer(33,474001612,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1317,5),line_char(1317,11))). -user:metta_file_buffer(33,474001612,string,"(Optional) description of what function will return. Starts with @return",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1317,12),line_char(1317,86))). -user:metta_file_buffer(32,474001612,metta_other,['@param',"(Optional) description of what function will return. Starts with @return"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1317,4),line_char(1317,87))). -user:metta_file_buffer(31,474001612,array,[['@param',"Function name"],['@param',"Function description. Starts with @desc"],['@param',"(Optional) parameters description starting with @params which should contain one or more @param symbols"],['@param',"(Optional) description of what function will return. Starts with @return"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1313,11),line_char(1317,88))). -user:metta_file_buffer(30,474001612,metta_other,['@params',[['@param',"Function name"],['@param',"Function description. Starts with @desc"],['@param',"(Optional) parameters description starting with @params which should contain one or more @param symbols"],['@param',"(Optional) description of what function will return. Starts with @return"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1313,2),line_char(1317,89))). -user:metta_file_buffer(31,474001613,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1318,3),line_char(1318,10))). -user:metta_file_buffer(31,474001613,string,"Function documentation using @doc-formal",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1318,11),line_char(1318,53))). -user:metta_file_buffer(30,474001613,metta_other,['@return',"Function documentation using @doc-formal"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1318,2),line_char(1318,54))). -user:metta_file_buffer(29,474001613,metta_other,['@doc','@doc',['@desc',"Used for documentation purposes. Function documentation starts with @doc"],['@params',[['@param',"Function name"],['@param',"Function description. Starts with @desc"],['@param',"(Optional) parameters description starting with @params which should contain one or more @param symbols"],['@param',"(Optional) description of what function will return. Starts with @return"]]],['@return',"Function documentation using @doc-formal"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1311,0),line_char(1318,55))). -user:metta_file_buffer(30,475001614,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1319,1),line_char(1319,2))). -user:metta_file_buffer(30,475001614,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1319,3),line_char(1319,7))). -user:metta_file_buffer(31,475001615,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1319,9),line_char(1319,11))). -user:metta_file_buffer(31,475001615,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1319,12),line_char(1319,16))). -user:metta_file_buffer(31,475001615,constant,'DocDescription',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1319,17),line_char(1319,31))). -user:metta_file_buffer(31,475001615,constant,'DocInformal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1319,32),line_char(1319,43))). -user:metta_file_buffer(30,475001615,metta_other,[->,'Atom','DocDescription','DocInformal'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1319,8),line_char(1319,44))). -user:metta_file_buffer(29,475001615,metta_typedecl,[:,'@doc',[->,'Atom','DocDescription','DocInformal']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1319,0),line_char(1319,45))). -user:metta_file_buffer(30,476001616,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1320,1),line_char(1320,2))). -user:metta_file_buffer(30,476001616,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1320,3),line_char(1320,7))). -user:metta_file_buffer(31,476001617,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1320,9),line_char(1320,11))). -user:metta_file_buffer(31,476001617,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1320,12),line_char(1320,16))). -user:metta_file_buffer(31,476001617,constant,'DocDescription',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1320,17),line_char(1320,31))). -user:metta_file_buffer(31,476001617,constant,'DocParameters',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1320,32),line_char(1320,45))). -user:metta_file_buffer(31,476001617,constant,'DocReturnInformal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1320,46),line_char(1320,63))). -user:metta_file_buffer(31,476001617,constant,'DocInformal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1320,64),line_char(1320,75))). -user:metta_file_buffer(30,476001617,metta_other,[->,'Atom','DocDescription','DocParameters','DocReturnInformal','DocInformal'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1320,8),line_char(1320,76))). -user:metta_file_buffer(29,476001617,metta_typedecl,[:,'@doc',[->,'Atom','DocDescription','DocParameters','DocReturnInformal','DocInformal']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1320,0),line_char(1320,77))). -user:metta_file_buffer(30,477001618,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1321,1),line_char(1321,3))). -user:metta_file_buffer(30,477001618,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1321,4),line_char(1321,8))). -user:metta_file_buffer(30,477001618,constant,'DataFunctor',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1321,9),line_char(1321,20))). -user:metta_file_buffer(29,477001618,metta_other,[iz,'@doc','DataFunctor'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1321,0),line_char(1321,21))). -user:metta_file_buffer(30,478001619,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1323,1),line_char(1323,3))). -user:metta_file_buffer(30,478001619,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1323,4),line_char(1323,9))). -user:metta_file_buffer(30,478001619,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1323,10),line_char(1323,15))). -user:metta_file_buffer(29,478001619,metta_other,[iz,'@desc','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1323,0),line_char(1323,16))). -user:metta_file_buffer(30,479001620,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1324,1),line_char(1324,5))). -user:metta_file_buffer(30,479001620,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1324,6),line_char(1324,11))). -user:metta_file_buffer(31,479001621,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1325,3),line_char(1325,8))). -user:metta_file_buffer(31,479001621,string,"Used for documentation purposes. Description of function starts with @desc as a part of @doc",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1325,9),line_char(1325,103))). -user:metta_file_buffer(30,479001621,metta_other,['@desc',"Used for documentation purposes. Description of function starts with @desc as a part of @doc"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1325,2),line_char(1325,104))). -user:metta_file_buffer(31,479001622,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1326,3),line_char(1326,10))). -user:metta_file_buffer(33,479001624,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1327,5),line_char(1327,11))). -user:metta_file_buffer(33,479001624,string,"String containing function description",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1327,12),line_char(1327,52))). -user:metta_file_buffer(32,479001624,metta_other,['@param',"String containing function description"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1327,4),line_char(1327,53))). -user:metta_file_buffer(31,479001624,array,[['@param',"String containing function description"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1326,11),line_char(1327,54))). -user:metta_file_buffer(30,479001624,metta_other,['@params',[['@param',"String containing function description"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1326,2),line_char(1327,55))). -user:metta_file_buffer(31,479001625,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1328,3),line_char(1328,10))). -user:metta_file_buffer(31,479001625,string,"Function description",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1328,11),line_char(1328,33))). -user:metta_file_buffer(30,479001625,metta_other,['@return',"Function description"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1328,2),line_char(1328,34))). -user:metta_file_buffer(29,479001625,metta_other,['@doc','@desc',['@desc',"Used for documentation purposes. Description of function starts with @desc as a part of @doc"],['@params',[['@param',"String containing function description"]]],['@return',"Function description"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1324,0),line_char(1328,35))). -user:metta_file_buffer(30,480001626,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1329,1),line_char(1329,2))). -user:metta_file_buffer(30,480001626,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1329,3),line_char(1329,8))). -user:metta_file_buffer(31,480001627,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1329,10),line_char(1329,12))). -user:metta_file_buffer(31,480001627,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1329,13),line_char(1329,19))). -user:metta_file_buffer(31,480001627,constant,'DocDescription',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1329,20),line_char(1329,34))). -user:metta_file_buffer(30,480001627,metta_other,[->,'String','DocDescription'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1329,9),line_char(1329,35))). -user:metta_file_buffer(29,480001627,metta_typedecl,[:,'@desc',[->,'String','DocDescription']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1329,0),line_char(1329,36))). -user:metta_file_buffer(30,481001628,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1330,1),line_char(1330,3))). -user:metta_file_buffer(30,481001628,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1330,4),line_char(1330,9))). -user:metta_file_buffer(30,481001628,constant,'DataFunctor',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1330,10),line_char(1330,21))). -user:metta_file_buffer(29,481001628,metta_other,[iz,'@desc','DataFunctor'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1330,0),line_char(1330,22))). -user:metta_file_buffer(30,482001629,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1332,1),line_char(1332,3))). -user:metta_file_buffer(30,482001629,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1332,4),line_char(1332,10))). -user:metta_file_buffer(30,482001629,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1332,11),line_char(1332,16))). -user:metta_file_buffer(29,482001629,metta_other,[iz,'@param','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1332,0),line_char(1332,17))). -user:metta_file_buffer(30,483001630,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1333,1),line_char(1333,5))). -user:metta_file_buffer(30,483001630,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1333,6),line_char(1333,12))). -user:metta_file_buffer(31,483001631,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1334,3),line_char(1334,8))). -user:metta_file_buffer(31,483001631,string,"Used for documentation purposes. Description of function parameter starts with @param as a part of @params which is a part of @doc",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1334,9),line_char(1334,141))). -user:metta_file_buffer(30,483001631,metta_other,['@desc',"Used for documentation purposes. Description of function parameter starts with @param as a part of @params which is a part of @doc"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1334,2),line_char(1334,142))). -user:metta_file_buffer(31,483001632,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1335,3),line_char(1335,10))). -user:metta_file_buffer(33,483001634,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1336,5),line_char(1336,11))). -user:metta_file_buffer(33,483001634,string,"String containing parameter description",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1336,12),line_char(1336,53))). -user:metta_file_buffer(32,483001634,metta_other,['@param',"String containing parameter description"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1336,4),line_char(1336,54))). -user:metta_file_buffer(31,483001634,array,[['@param',"String containing parameter description"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1335,11),line_char(1336,55))). -user:metta_file_buffer(30,483001634,metta_other,['@params',[['@param',"String containing parameter description"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1335,2),line_char(1336,56))). -user:metta_file_buffer(31,483001635,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1337,3),line_char(1337,10))). -user:metta_file_buffer(31,483001635,string,"Parameter description",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1337,11),line_char(1337,34))). -user:metta_file_buffer(30,483001635,metta_other,['@return',"Parameter description"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1337,2),line_char(1337,35))). -user:metta_file_buffer(29,483001635,metta_other,['@doc','@param',['@desc',"Used for documentation purposes. Description of function parameter starts with @param as a part of @params which is a part of @doc"],['@params',[['@param',"String containing parameter description"]]],['@return',"Parameter description"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1333,0),line_char(1337,36))). -user:metta_file_buffer(30,484001636,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1338,1),line_char(1338,2))). -user:metta_file_buffer(30,484001636,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1338,3),line_char(1338,9))). -user:metta_file_buffer(31,484001637,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1338,11),line_char(1338,13))). -user:metta_file_buffer(31,484001637,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1338,14),line_char(1338,20))). -user:metta_file_buffer(31,484001637,constant,'DocParameterInformal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1338,21),line_char(1338,41))). -user:metta_file_buffer(30,484001637,metta_other,[->,'String','DocParameterInformal'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1338,10),line_char(1338,42))). -user:metta_file_buffer(29,484001637,metta_typedecl,[:,'@param',[->,'String','DocParameterInformal']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1338,0),line_char(1338,43))). -user:metta_file_buffer(30,485001638,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1339,1),line_char(1339,2))). -user:metta_file_buffer(30,485001638,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1339,3),line_char(1339,9))). -user:metta_file_buffer(31,485001639,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1339,11),line_char(1339,13))). -user:metta_file_buffer(31,485001639,constant,'DocType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1339,14),line_char(1339,21))). -user:metta_file_buffer(31,485001639,constant,'DocDescription',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1339,22),line_char(1339,36))). -user:metta_file_buffer(31,485001639,constant,'DocParameter',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1339,37),line_char(1339,49))). -user:metta_file_buffer(30,485001639,metta_other,[->,'DocType','DocDescription','DocParameter'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1339,10),line_char(1339,50))). -user:metta_file_buffer(29,485001639,metta_typedecl,[:,'@param',[->,'DocType','DocDescription','DocParameter']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1339,0),line_char(1339,51))). -user:metta_file_buffer(30,486001640,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1340,1),line_char(1340,3))). -user:metta_file_buffer(30,486001640,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1340,4),line_char(1340,10))). -user:metta_file_buffer(30,486001640,constant,'DataFunctor',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1340,11),line_char(1340,22))). -user:metta_file_buffer(29,486001640,metta_other,[iz,'@param','DataFunctor'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1340,0),line_char(1340,23))). -user:metta_file_buffer(30,487001641,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1342,1),line_char(1342,3))). -user:metta_file_buffer(30,487001641,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1342,4),line_char(1342,11))). -user:metta_file_buffer(30,487001641,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1342,12),line_char(1342,17))). -user:metta_file_buffer(29,487001641,metta_other,[iz,'@return','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1342,0),line_char(1342,18))). -user:metta_file_buffer(30,488001642,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1343,1),line_char(1343,5))). -user:metta_file_buffer(30,488001642,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1343,6),line_char(1343,13))). -user:metta_file_buffer(31,488001643,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1344,3),line_char(1344,8))). -user:metta_file_buffer(31,488001643,string,"Used for documentation purposes. Description of function return value starts with @return as a part of @doc",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1344,9),line_char(1344,118))). -user:metta_file_buffer(30,488001643,metta_other,['@desc',"Used for documentation purposes. Description of function return value starts with @return as a part of @doc"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1344,2),line_char(1344,119))). -user:metta_file_buffer(31,488001644,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1345,3),line_char(1345,10))). -user:metta_file_buffer(33,488001646,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1346,5),line_char(1346,11))). -user:metta_file_buffer(33,488001646,string,"String containing return value description",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1346,12),line_char(1346,56))). -user:metta_file_buffer(32,488001646,metta_other,['@param',"String containing return value description"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1346,4),line_char(1346,57))). -user:metta_file_buffer(31,488001646,array,[['@param',"String containing return value description"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1345,11),line_char(1346,58))). -user:metta_file_buffer(30,488001646,metta_other,['@params',[['@param',"String containing return value description"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1345,2),line_char(1346,59))). -user:metta_file_buffer(31,488001647,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1347,3),line_char(1347,10))). -user:metta_file_buffer(31,488001647,string,"Return value description",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1347,11),line_char(1347,37))). -user:metta_file_buffer(30,488001647,metta_other,['@return',"Return value description"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1347,2),line_char(1347,38))). -user:metta_file_buffer(29,488001647,metta_other,['@doc','@return',['@desc',"Used for documentation purposes. Description of function return value starts with @return as a part of @doc"],['@params',[['@param',"String containing return value description"]]],['@return',"Return value description"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1343,0),line_char(1347,39))). -user:metta_file_buffer(30,489001648,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1348,1),line_char(1348,2))). -user:metta_file_buffer(30,489001648,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1348,3),line_char(1348,10))). -user:metta_file_buffer(31,489001649,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1348,12),line_char(1348,14))). -user:metta_file_buffer(31,489001649,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1348,15),line_char(1348,21))). -user:metta_file_buffer(31,489001649,constant,'DocReturnInformal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1348,22),line_char(1348,39))). -user:metta_file_buffer(30,489001649,metta_other,[->,'String','DocReturnInformal'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1348,11),line_char(1348,40))). -user:metta_file_buffer(29,489001649,metta_typedecl,[:,'@return',[->,'String','DocReturnInformal']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1348,0),line_char(1348,41))). -user:metta_file_buffer(30,490001650,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1349,1),line_char(1349,2))). -user:metta_file_buffer(30,490001650,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1349,3),line_char(1349,10))). -user:metta_file_buffer(31,490001651,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1349,12),line_char(1349,14))). -user:metta_file_buffer(31,490001651,constant,'DocType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1349,15),line_char(1349,22))). -user:metta_file_buffer(31,490001651,constant,'DocDescription',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1349,23),line_char(1349,37))). -user:metta_file_buffer(31,490001651,constant,'DocReturn',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1349,38),line_char(1349,47))). -user:metta_file_buffer(30,490001651,metta_other,[->,'DocType','DocDescription','DocReturn'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1349,11),line_char(1349,48))). -user:metta_file_buffer(29,490001651,metta_typedecl,[:,'@return',[->,'DocType','DocDescription','DocReturn']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1349,0),line_char(1349,49))). -user:metta_file_buffer(30,491001652,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1350,1),line_char(1350,3))). -user:metta_file_buffer(30,491001652,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1350,4),line_char(1350,11))). -user:metta_file_buffer(30,491001652,constant,'DataFunctor',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1350,12),line_char(1350,23))). -user:metta_file_buffer(29,491001652,metta_other,[iz,'@return','DataFunctor'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1350,0),line_char(1350,24))). -user:metta_file_buffer(30,492001653,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1352,1),line_char(1352,3))). -user:metta_file_buffer(30,492001653,constant,'@doc-formal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1352,4),line_char(1352,15))). -user:metta_file_buffer(30,492001653,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1352,16),line_char(1352,21))). -user:metta_file_buffer(29,492001653,metta_other,[iz,'@doc-formal','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1352,0),line_char(1352,22))). -user:metta_file_buffer(30,493001654,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1353,1),line_char(1353,5))). -user:metta_file_buffer(30,493001654,constant,'@doc-formal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1353,6),line_char(1353,17))). -user:metta_file_buffer(31,493001655,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1354,3),line_char(1354,8))). -user:metta_file_buffer(31,493001655,string,"Used for documentation purposes. get-doc returns documentation starting with @doc-formal symbol. @doc-formal contains 6 or 4 parameters depending on the entity being described (functions being described using 6 parameters, atoms - 4 parameters)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1354,9),line_char(1354,255))). -user:metta_file_buffer(30,493001655,metta_other,['@desc',"Used for documentation purposes. get-doc returns documentation starting with @doc-formal symbol. @doc-formal contains 6 or 4 parameters depending on the entity being described (functions being described using 6 parameters, atoms - 4 parameters)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1354,2),line_char(1354,256))). -user:metta_file_buffer(31,493001656,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1355,3),line_char(1355,10))). -user:metta_file_buffer(33,493001658,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1356,5),line_char(1356,11))). -user:metta_file_buffer(33,493001658,string,"Function/Atom name for which documentation is to be displayed. Format (@item name)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1356,12),line_char(1356,96))). -user:metta_file_buffer(32,493001658,metta_other,['@param',"Function/Atom name for which documentation is to be displayed. Format (@item name)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1356,4),line_char(1356,97))). -user:metta_file_buffer(33,493001659,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1357,5),line_char(1357,11))). -user:metta_file_buffer(33,493001659,string,"Contains (@kind function) or (@kind atom) depends on entity which documentation is displayed",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1357,12),line_char(1357,106))). -user:metta_file_buffer(32,493001659,metta_other,['@param',"Contains (@kind function) or (@kind atom) depends on entity which documentation is displayed"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1357,4),line_char(1357,107))). -user:metta_file_buffer(33,493001660,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1358,5),line_char(1358,11))). -user:metta_file_buffer(33,493001660,string,"Contains type notation of function/atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1358,12),line_char(1358,53))). -user:metta_file_buffer(32,493001660,metta_other,['@param',"Contains type notation of function/atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1358,4),line_char(1358,54))). -user:metta_file_buffer(33,493001661,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1359,5),line_char(1359,11))). -user:metta_file_buffer(33,493001661,string,"Function/atom description",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1359,12),line_char(1359,39))). -user:metta_file_buffer(32,493001661,metta_other,['@param',"Function/atom description"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1359,4),line_char(1359,40))). -user:metta_file_buffer(33,493001662,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1360,5),line_char(1360,11))). -user:metta_file_buffer(33,493001662,string,"(Functions only). Description of function parameters",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1360,12),line_char(1360,66))). -user:metta_file_buffer(32,493001662,metta_other,['@param',"(Functions only). Description of function parameters"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1360,4),line_char(1360,67))). -user:metta_file_buffer(33,493001663,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1361,5),line_char(1361,11))). -user:metta_file_buffer(33,493001663,string,"(Functions only). Description of function's return value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1361,12),line_char(1361,70))). -user:metta_file_buffer(32,493001663,metta_other,['@param',"(Functions only). Description of function's return value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1361,4),line_char(1361,71))). -user:metta_file_buffer(31,493001663,array,[['@param',"Function/Atom name for which documentation is to be displayed. Format (@item name)"],['@param',"Contains (@kind function) or (@kind atom) depends on entity which documentation is displayed"],['@param',"Contains type notation of function/atom"],['@param',"Function/atom description"],['@param',"(Functions only). Description of function parameters"],['@param',"(Functions only). Description of function's return value"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1355,11),line_char(1361,72))). -user:metta_file_buffer(30,493001663,metta_other,['@params',[['@param',"Function/Atom name for which documentation is to be displayed. Format (@item name)"],['@param',"Contains (@kind function) or (@kind atom) depends on entity which documentation is displayed"],['@param',"Contains type notation of function/atom"],['@param',"Function/atom description"],['@param',"(Functions only). Description of function parameters"],['@param',"(Functions only). Description of function's return value"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1355,2),line_char(1361,73))). -user:metta_file_buffer(31,493001664,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1362,3),line_char(1362,10))). -user:metta_file_buffer(31,493001664,string,"Expression containing full documentation on function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1362,11),line_char(1362,65))). -user:metta_file_buffer(30,493001664,metta_other,['@return',"Expression containing full documentation on function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1362,2),line_char(1362,66))). -user:metta_file_buffer(29,493001664,metta_other,['@doc','@doc-formal',['@desc',"Used for documentation purposes. get-doc returns documentation starting with @doc-formal symbol. @doc-formal contains 6 or 4 parameters depending on the entity being described (functions being described using 6 parameters, atoms - 4 parameters)"],['@params',[['@param',"Function/Atom name for which documentation is to be displayed. Format (@item name)"],['@param',"Contains (@kind function) or (@kind atom) depends on entity which documentation is displayed"],['@param',"Contains type notation of function/atom"],['@param',"Function/atom description"],['@param',"(Functions only). Description of function parameters"],['@param',"(Functions only). Description of function's return value"]]],['@return',"Expression containing full documentation on function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1353,0),line_char(1362,67))). -user:metta_file_buffer(30,494001665,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1363,1),line_char(1363,2))). -user:metta_file_buffer(30,494001665,constant,'@doc-formal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1363,3),line_char(1363,14))). -user:metta_file_buffer(31,494001666,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1363,16),line_char(1363,18))). -user:metta_file_buffer(31,494001666,constant,'DocItem',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1363,19),line_char(1363,26))). -user:metta_file_buffer(31,494001666,constant,'DocKindFunction',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1363,27),line_char(1363,42))). -user:metta_file_buffer(31,494001666,constant,'DocType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1363,43),line_char(1363,50))). -user:metta_file_buffer(31,494001666,constant,'DocDescription',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1363,51),line_char(1363,65))). -user:metta_file_buffer(31,494001666,constant,'DocParameters',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1363,66),line_char(1363,79))). -user:metta_file_buffer(31,494001666,constant,'DocReturn',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1363,80),line_char(1363,89))). -user:metta_file_buffer(31,494001666,constant,'DocFormal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1363,90),line_char(1363,99))). -user:metta_file_buffer(30,494001666,metta_other,[->,'DocItem','DocKindFunction','DocType','DocDescription','DocParameters','DocReturn','DocFormal'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1363,15),line_char(1363,100))). -user:metta_file_buffer(29,494001666,metta_typedecl,[:,'@doc-formal',[->,'DocItem','DocKindFunction','DocType','DocDescription','DocParameters','DocReturn','DocFormal']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1363,0),line_char(1363,101))). -user:metta_file_buffer(30,495001667,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1364,1),line_char(1364,2))). -user:metta_file_buffer(30,495001667,constant,'@doc-formal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1364,3),line_char(1364,14))). -user:metta_file_buffer(31,495001668,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1364,16),line_char(1364,18))). -user:metta_file_buffer(31,495001668,constant,'DocItem',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1364,19),line_char(1364,26))). -user:metta_file_buffer(31,495001668,constant,'DocKindAtom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1364,27),line_char(1364,38))). -user:metta_file_buffer(31,495001668,constant,'DocType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1364,39),line_char(1364,46))). -user:metta_file_buffer(31,495001668,constant,'DocDescription',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1364,47),line_char(1364,61))). -user:metta_file_buffer(31,495001668,constant,'DocFormal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1364,62),line_char(1364,71))). -user:metta_file_buffer(30,495001668,metta_other,[->,'DocItem','DocKindAtom','DocType','DocDescription','DocFormal'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1364,15),line_char(1364,72))). -user:metta_file_buffer(29,495001668,metta_typedecl,[:,'@doc-formal',[->,'DocItem','DocKindAtom','DocType','DocDescription','DocFormal']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1364,0),line_char(1364,73))). -user:metta_file_buffer(30,496001669,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1365,1),line_char(1365,3))). -user:metta_file_buffer(30,496001669,constant,'@doc-formal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1365,4),line_char(1365,15))). -user:metta_file_buffer(30,496001669,constant,'DataFunctor',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1365,16),line_char(1365,27))). -user:metta_file_buffer(29,496001669,metta_other,[iz,'@doc-formal','DataFunctor'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1365,0),line_char(1365,28))). -user:metta_file_buffer(30,497001670,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1367,1),line_char(1367,3))). -user:metta_file_buffer(30,497001670,constant,'@item',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1367,4),line_char(1367,9))). -user:metta_file_buffer(30,497001670,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1367,10),line_char(1367,15))). -user:metta_file_buffer(29,497001670,metta_other,[iz,'@item','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1367,0),line_char(1367,16))). -user:metta_file_buffer(30,498001671,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1368,1),line_char(1368,5))). -user:metta_file_buffer(30,498001671,constant,'@item',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1368,6),line_char(1368,11))). -user:metta_file_buffer(31,498001672,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1369,3),line_char(1369,8))). -user:metta_file_buffer(31,498001672,string,"Used for documentation purposes. Converts atom/function's name to DocItem",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1369,9),line_char(1369,84))). -user:metta_file_buffer(30,498001672,metta_other,['@desc',"Used for documentation purposes. Converts atom/function's name to DocItem"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1369,2),line_char(1369,85))). -user:metta_file_buffer(31,498001673,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1370,3),line_char(1370,10))). -user:metta_file_buffer(33,498001675,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1371,5),line_char(1371,11))). -user:metta_file_buffer(33,498001675,string,"Atom/Function name to be documented",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1371,12),line_char(1371,49))). -user:metta_file_buffer(32,498001675,metta_other,['@param',"Atom/Function name to be documented"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1371,4),line_char(1371,50))). -user:metta_file_buffer(31,498001675,array,[['@param',"Atom/Function name to be documented"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1370,11),line_char(1371,51))). -user:metta_file_buffer(30,498001675,metta_other,['@params',[['@param',"Atom/Function name to be documented"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1370,2),line_char(1371,52))). -user:metta_file_buffer(31,498001676,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1372,3),line_char(1372,10))). -user:metta_file_buffer(31,498001676,string,"(@item Atom) entity",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1372,11),line_char(1372,32))). -user:metta_file_buffer(30,498001676,metta_other,['@return',"(@item Atom) entity"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1372,2),line_char(1372,33))). -user:metta_file_buffer(29,498001676,metta_other,['@doc','@item',['@desc',"Used for documentation purposes. Converts atom/function's name to DocItem"],['@params',[['@param',"Atom/Function name to be documented"]]],['@return',"(@item Atom) entity"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1368,0),line_char(1372,34))). -user:metta_file_buffer(30,499001677,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1373,1),line_char(1373,2))). -user:metta_file_buffer(30,499001677,constant,'@item',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1373,3),line_char(1373,8))). -user:metta_file_buffer(31,499001678,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1373,10),line_char(1373,12))). -user:metta_file_buffer(31,499001678,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1373,13),line_char(1373,17))). -user:metta_file_buffer(31,499001678,constant,'DocItem',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1373,18),line_char(1373,25))). -user:metta_file_buffer(30,499001678,metta_other,[->,'Atom','DocItem'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1373,9),line_char(1373,26))). -user:metta_file_buffer(29,499001678,metta_typedecl,[:,'@item',[->,'Atom','DocItem']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1373,0),line_char(1373,27))). -user:metta_file_buffer(30,500001679,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1374,1),line_char(1374,3))). -user:metta_file_buffer(30,500001679,constant,'@item',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1374,4),line_char(1374,9))). -user:metta_file_buffer(30,500001679,constant,'DataFunctor',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1374,10),line_char(1374,21))). -user:metta_file_buffer(29,500001679,metta_other,[iz,'@item','DataFunctor'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1374,0),line_char(1374,22))). -user:metta_file_buffer(29,501001679,indexed(metta_comment,"; TODO: help! gives two outputs"),'$COMMENT'("; TODO: help! gives two outputs",1376,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1376,0),line_char(1376,31))). -user:metta_file_buffer(29,501001679,indexed(metta_comment,";Atom (@kind function): (%Undefined% (-> Atom Atom)) Used for documentation purposes. Shows type of entity to be documented. (@kind function) in this case"),'$COMMENT'(";Atom (@kind function): (%Undefined% (-> Atom Atom)) Used for documentation purposes. Shows type of entity to be documented. (@kind function) in this case",1377,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1377,0),line_char(1377,154))). -user:metta_file_buffer(29,501001679,indexed(metta_comment,";Atom (@kind function): DocKindFunction Used for documentation purposes. Shows type of entity to be documented. (@kind function) in this case"),'$COMMENT'(";Atom (@kind function): DocKindFunction Used for documentation purposes. Shows type of entity to be documented. (@kind function) in this case",1378,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1378,0),line_char(1378,141))). -user:metta_file_buffer(30,501001680,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1379,1),line_char(1379,3))). -user:metta_file_buffer(31,501001681,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1379,5),line_char(1379,10))). -user:metta_file_buffer(31,501001681,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1379,11),line_char(1379,19))). -user:metta_file_buffer(30,501001681,metta_other,['@kind',function],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1379,4),line_char(1379,20))). -user:metta_file_buffer(30,501001681,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1379,21),line_char(1379,26))). -user:metta_file_buffer(29,501001681,metta_other,[iz,['@kind',function],'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1379,0),line_char(1379,27))). -user:metta_file_buffer(30,502001682,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1380,1),line_char(1380,5))). -user:metta_file_buffer(31,502001683,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1380,7),line_char(1380,12))). -user:metta_file_buffer(31,502001683,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1380,13),line_char(1380,21))). -user:metta_file_buffer(30,502001683,metta_other,['@kind',function],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1380,6),line_char(1380,22))). -user:metta_file_buffer(31,502001684,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1381,3),line_char(1381,8))). -user:metta_file_buffer(31,502001684,string,"Used for documentation purposes. Shows type of entity to be documented. (@kind function) in this case",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1381,9),line_char(1381,112))). -user:metta_file_buffer(30,502001684,metta_other,['@desc',"Used for documentation purposes. Shows type of entity to be documented. (@kind function) in this case"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1381,2),line_char(1381,113))). -user:metta_file_buffer(29,502001684,metta_other,['@doc',['@kind',function],['@desc',"Used for documentation purposes. Shows type of entity to be documented. (@kind function) in this case"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1380,0),line_char(1381,114))). -user:metta_file_buffer(30,503001685,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1382,1),line_char(1382,2))). -user:metta_file_buffer(31,503001686,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1382,4),line_char(1382,9))). -user:metta_file_buffer(31,503001686,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1382,10),line_char(1382,18))). -user:metta_file_buffer(30,503001686,metta_other,['@kind',function],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1382,3),line_char(1382,19))). -user:metta_file_buffer(30,503001686,constant,'DocKindFunction',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1382,20),line_char(1382,35))). -user:metta_file_buffer(29,503001686,metta_typedecl,[:,['@kind',function],'DocKindFunction'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1382,0),line_char(1382,36))). -user:metta_file_buffer(30,504001687,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1383,1),line_char(1383,3))). -user:metta_file_buffer(31,504001688,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1383,5),line_char(1383,10))). -user:metta_file_buffer(31,504001688,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1383,11),line_char(1383,19))). -user:metta_file_buffer(30,504001688,metta_other,['@kind',function],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1383,4),line_char(1383,20))). -user:metta_file_buffer(30,504001688,constant,'DataFunctor',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1383,21),line_char(1383,32))). -user:metta_file_buffer(29,504001688,metta_other,[iz,['@kind',function],'DataFunctor'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1383,0),line_char(1383,33))). -user:metta_file_buffer(30,505001689,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1385,1),line_char(1385,3))). -user:metta_file_buffer(31,505001690,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1385,5),line_char(1385,10))). -user:metta_file_buffer(31,505001690,constant,atom,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1385,11),line_char(1385,15))). -user:metta_file_buffer(30,505001690,metta_other,['@kind',atom],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1385,4),line_char(1385,16))). -user:metta_file_buffer(30,505001690,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1385,17),line_char(1385,22))). -user:metta_file_buffer(29,505001690,metta_other,[iz,['@kind',atom],'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1385,0),line_char(1385,23))). -user:metta_file_buffer(30,506001691,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1386,1),line_char(1386,5))). -user:metta_file_buffer(31,506001692,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1386,7),line_char(1386,12))). -user:metta_file_buffer(31,506001692,constant,atom,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1386,13),line_char(1386,17))). -user:metta_file_buffer(30,506001692,metta_other,['@kind',atom],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1386,6),line_char(1386,18))). -user:metta_file_buffer(31,506001693,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1387,3),line_char(1387,8))). -user:metta_file_buffer(31,506001693,string,"Used for documentation purposes. Shows type of entity to be documented. (@kind atom) in this case",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1387,9),line_char(1387,108))). -user:metta_file_buffer(30,506001693,metta_other,['@desc',"Used for documentation purposes. Shows type of entity to be documented. (@kind atom) in this case"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1387,2),line_char(1387,109))). -user:metta_file_buffer(29,506001693,metta_other,['@doc',['@kind',atom],['@desc',"Used for documentation purposes. Shows type of entity to be documented. (@kind atom) in this case"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1386,0),line_char(1387,110))). -user:metta_file_buffer(30,507001694,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1388,1),line_char(1388,2))). -user:metta_file_buffer(31,507001695,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1388,4),line_char(1388,9))). -user:metta_file_buffer(31,507001695,constant,atom,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1388,10),line_char(1388,14))). -user:metta_file_buffer(30,507001695,metta_other,['@kind',atom],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1388,3),line_char(1388,15))). -user:metta_file_buffer(30,507001695,constant,'DocKindAtom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1388,16),line_char(1388,27))). -user:metta_file_buffer(29,507001695,metta_typedecl,[:,['@kind',atom],'DocKindAtom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1388,0),line_char(1388,28))). -user:metta_file_buffer(30,508001696,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1389,1),line_char(1389,3))). -user:metta_file_buffer(31,508001697,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1389,5),line_char(1389,10))). -user:metta_file_buffer(31,508001697,constant,atom,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1389,11),line_char(1389,15))). -user:metta_file_buffer(30,508001697,metta_other,['@kind',atom],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1389,4),line_char(1389,16))). -user:metta_file_buffer(30,508001697,constant,'DataFunctor',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1389,17),line_char(1389,28))). -user:metta_file_buffer(29,508001697,metta_other,[iz,['@kind',atom],'DataFunctor'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1389,0),line_char(1389,29))). -user:metta_file_buffer(30,509001698,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1391,1),line_char(1391,3))). -user:metta_file_buffer(30,509001698,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1391,4),line_char(1391,9))). -user:metta_file_buffer(30,509001698,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1391,10),line_char(1391,15))). -user:metta_file_buffer(29,509001698,metta_other,[iz,'@type','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1391,0),line_char(1391,16))). -user:metta_file_buffer(30,510001699,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1392,1),line_char(1392,5))). -user:metta_file_buffer(30,510001699,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1392,6),line_char(1392,11))). -user:metta_file_buffer(31,510001700,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1393,3),line_char(1393,8))). -user:metta_file_buffer(31,510001700,string,"Used for documentation purposes. Converts atom/function's type to DocType",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1393,9),line_char(1393,84))). -user:metta_file_buffer(30,510001700,metta_other,['@desc',"Used for documentation purposes. Converts atom/function's type to DocType"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1393,2),line_char(1393,85))). -user:metta_file_buffer(31,510001701,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1394,3),line_char(1394,10))). -user:metta_file_buffer(33,510001703,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1395,5),line_char(1395,11))). -user:metta_file_buffer(33,510001703,string,"Atom/Function type to be documented",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1395,12),line_char(1395,49))). -user:metta_file_buffer(32,510001703,metta_other,['@param',"Atom/Function type to be documented"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1395,4),line_char(1395,50))). -user:metta_file_buffer(31,510001703,array,[['@param',"Atom/Function type to be documented"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1394,11),line_char(1395,51))). -user:metta_file_buffer(30,510001703,metta_other,['@params',[['@param',"Atom/Function type to be documented"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1394,2),line_char(1395,52))). -user:metta_file_buffer(31,510001704,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1396,3),line_char(1396,10))). -user:metta_file_buffer(31,510001704,string,"(@type Type) entity",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1396,11),line_char(1396,32))). -user:metta_file_buffer(30,510001704,metta_other,['@return',"(@type Type) entity"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1396,2),line_char(1396,33))). -user:metta_file_buffer(29,510001704,metta_other,['@doc','@type',['@desc',"Used for documentation purposes. Converts atom/function's type to DocType"],['@params',[['@param',"Atom/Function type to be documented"]]],['@return',"(@type Type) entity"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1392,0),line_char(1396,34))). -user:metta_file_buffer(30,511001705,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1397,1),line_char(1397,2))). -user:metta_file_buffer(30,511001705,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1397,3),line_char(1397,8))). -user:metta_file_buffer(31,511001706,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1397,10),line_char(1397,12))). -user:metta_file_buffer(31,511001706,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1397,13),line_char(1397,17))). -user:metta_file_buffer(31,511001706,constant,'DocType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1397,18),line_char(1397,25))). -user:metta_file_buffer(30,511001706,metta_other,[->,'Type','DocType'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1397,9),line_char(1397,26))). -user:metta_file_buffer(29,511001706,metta_typedecl,[:,'@type',[->,'Type','DocType']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1397,0),line_char(1397,27))). -user:metta_file_buffer(30,512001707,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1398,1),line_char(1398,3))). -user:metta_file_buffer(30,512001707,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1398,4),line_char(1398,9))). -user:metta_file_buffer(30,512001707,constant,'DataFunctor',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1398,10),line_char(1398,21))). -user:metta_file_buffer(29,512001707,metta_other,[iz,'@type','DataFunctor'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1398,0),line_char(1398,22))). -user:metta_file_buffer(30,513001708,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1400,1),line_char(1400,3))). -user:metta_file_buffer(30,513001708,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1400,4),line_char(1400,11))). -user:metta_file_buffer(30,513001708,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1400,12),line_char(1400,17))). -user:metta_file_buffer(29,513001708,metta_other,[iz,'@params','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1400,0),line_char(1400,18))). -user:metta_file_buffer(30,514001709,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1401,1),line_char(1401,5))). -user:metta_file_buffer(30,514001709,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1401,6),line_char(1401,13))). -user:metta_file_buffer(31,514001710,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1402,3),line_char(1402,8))). -user:metta_file_buffer(31,514001710,string,"Used for function documentation purposes. Contains several @param entities with description of each @param",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1402,9),line_char(1402,117))). -user:metta_file_buffer(30,514001710,metta_other,['@desc',"Used for function documentation purposes. Contains several @param entities with description of each @param"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1402,2),line_char(1402,118))). -user:metta_file_buffer(31,514001711,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1403,3),line_char(1403,10))). -user:metta_file_buffer(33,514001713,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1404,5),line_char(1404,11))). -user:metta_file_buffer(33,514001713,string,"Several (@param ...) entities",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1404,12),line_char(1404,43))). -user:metta_file_buffer(32,514001713,metta_other,['@param',"Several (@param ...) entities"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1404,4),line_char(1404,44))). -user:metta_file_buffer(31,514001713,array,[['@param',"Several (@param ...) entities"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1403,11),line_char(1404,45))). -user:metta_file_buffer(30,514001713,metta_other,['@params',[['@param',"Several (@param ...) entities"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1403,2),line_char(1404,46))). -user:metta_file_buffer(31,514001714,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1405,3),line_char(1405,10))). -user:metta_file_buffer(31,514001714,string,"DocParameters containing description of all parameters of function in form of (@params ((@param ...) (@param ...) ...))",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1405,11),line_char(1405,132))). -user:metta_file_buffer(30,514001714,metta_other,['@return',"DocParameters containing description of all parameters of function in form of (@params ((@param ...) (@param ...) ...))"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1405,2),line_char(1405,133))). -user:metta_file_buffer(29,514001714,metta_other,['@doc','@params',['@desc',"Used for function documentation purposes. Contains several @param entities with description of each @param"],['@params',[['@param',"Several (@param ...) entities"]]],['@return',"DocParameters containing description of all parameters of function in form of (@params ((@param ...) (@param ...) ...))"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1401,0),line_char(1405,134))). -user:metta_file_buffer(30,515001715,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1406,1),line_char(1406,2))). -user:metta_file_buffer(30,515001715,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1406,3),line_char(1406,10))). -user:metta_file_buffer(31,515001716,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1406,12),line_char(1406,14))). -user:metta_file_buffer(31,515001716,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1406,15),line_char(1406,25))). -user:metta_file_buffer(31,515001716,constant,'DocParameters',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1406,26),line_char(1406,39))). -user:metta_file_buffer(30,515001716,metta_other,[->,'Expression','DocParameters'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1406,11),line_char(1406,40))). -user:metta_file_buffer(29,515001716,metta_typedecl,[:,'@params',[->,'Expression','DocParameters']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1406,0),line_char(1406,41))). -user:metta_file_buffer(30,516001717,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1407,1),line_char(1407,3))). -user:metta_file_buffer(30,516001717,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1407,4),line_char(1407,11))). -user:metta_file_buffer(30,516001717,constant,'DataFunctor',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1407,12),line_char(1407,23))). -user:metta_file_buffer(29,516001717,metta_other,[iz,'@params','DataFunctor'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1407,0),line_char(1407,24))). -user:metta_file_buffer(30,517001718,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1409,1),line_char(1409,3))). -user:metta_file_buffer(30,517001718,constant,'get-doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1409,4),line_char(1409,11))). -user:metta_file_buffer(30,517001718,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1409,12),line_char(1409,17))). -user:metta_file_buffer(29,517001718,metta_other,[iz,'get-doc','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1409,0),line_char(1409,18))). -user:metta_file_buffer(30,518001719,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1410,1),line_char(1410,5))). -user:metta_file_buffer(30,518001719,constant,'get-doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1410,6),line_char(1410,13))). -user:metta_file_buffer(31,518001720,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1411,3),line_char(1411,8))). -user:metta_file_buffer(31,518001720,string,"Returns documentation for the given Atom/Function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1411,9),line_char(1411,60))). -user:metta_file_buffer(30,518001720,metta_other,['@desc',"Returns documentation for the given Atom/Function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1411,2),line_char(1411,61))). -user:metta_file_buffer(31,518001721,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1412,3),line_char(1412,10))). -user:metta_file_buffer(33,518001723,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1413,5),line_char(1413,11))). -user:metta_file_buffer(33,518001723,string,"Atom/Function name for which documentation is needed",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1413,12),line_char(1413,66))). -user:metta_file_buffer(32,518001723,metta_other,['@param',"Atom/Function name for which documentation is needed"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1413,4),line_char(1413,67))). -user:metta_file_buffer(31,518001723,array,[['@param',"Atom/Function name for which documentation is needed"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1412,11),line_char(1413,68))). -user:metta_file_buffer(30,518001723,metta_other,['@params',[['@param',"Atom/Function name for which documentation is needed"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1412,2),line_char(1413,69))). -user:metta_file_buffer(31,518001724,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1414,3),line_char(1414,10))). -user:metta_file_buffer(31,518001724,string,"Documentation for the given atom/function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1414,11),line_char(1414,54))). -user:metta_file_buffer(30,518001724,metta_other,['@return',"Documentation for the given atom/function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1414,2),line_char(1414,55))). -user:metta_file_buffer(29,518001724,metta_other,['@doc','get-doc',['@desc',"Returns documentation for the given Atom/Function"],['@params',[['@param',"Atom/Function name for which documentation is needed"]]],['@return',"Documentation for the given atom/function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1410,0),line_char(1414,56))). -user:metta_file_buffer(30,519001725,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1415,1),line_char(1415,2))). -user:metta_file_buffer(30,519001725,constant,'get-doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1415,3),line_char(1415,10))). -user:metta_file_buffer(31,519001726,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1415,12),line_char(1415,14))). -user:metta_file_buffer(31,519001726,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1415,15),line_char(1415,19))). -user:metta_file_buffer(31,519001726,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1415,20),line_char(1415,24))). -user:metta_file_buffer(30,519001726,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1415,11),line_char(1415,25))). -user:metta_file_buffer(29,519001726,metta_typedecl,[:,'get-doc',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1415,0),line_char(1415,26))). -user:metta_file_buffer(30,520001727,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1416,1),line_char(1416,2))). -user:metta_file_buffer(30,520001727,constant,'metta-get-doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1416,3),line_char(1416,16))). -user:metta_file_buffer(31,520001728,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1416,18),line_char(1416,20))). -user:metta_file_buffer(31,520001728,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1416,21),line_char(1416,25))). -user:metta_file_buffer(31,520001728,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1416,26),line_char(1416,30))). -user:metta_file_buffer(30,520001728,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1416,17),line_char(1416,31))). -user:metta_file_buffer(29,520001728,metta_typedecl,[:,'metta-get-doc',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1416,0),line_char(1416,32))). -user:metta_file_buffer(30,521001729,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1417,1),line_char(1417,2))). -user:metta_file_buffer(31,521001730,constant,'metta-get-doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1417,4),line_char(1417,17))). -user:metta_file_buffer(31,521001730,variable,_261426,['_atom'=_261426],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1417,18),line_char(1417,23))). -user:metta_file_buffer(30,521001730,indexed(metta_other,['metta-get-doc',_262260]),['metta-get-doc',_262312],['_atom'=_262312],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1417,3),line_char(1417,24))). -user:metta_file_buffer(31,521001731,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1418,3),line_char(1418,6))). -user:metta_file_buffer(31,521001731,variable,_264174,['_meta_type'=_264174],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1418,7),line_char(1418,17))). -user:metta_file_buffer(32,521001732,constant,'get-metatype',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1418,19),line_char(1418,31))). -user:metta_file_buffer(32,521001732,variable,_266272,['_atom'=_266272],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1418,32),line_char(1418,37))). -user:metta_file_buffer(31,521001732,indexed(metta_other,['get-metatype',_267106]),['get-metatype',_267158],['_atom'=_267158],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1418,18),line_char(1418,38))). -user:metta_file_buffer(32,521001733,constant,case,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1419,5),line_char(1419,9))). -user:metta_file_buffer(32,521001733,variable,_269034,['_meta_type'=_269034],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1419,10),line_char(1419,20))). -user:metta_file_buffer(34,521001735,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1420,7),line_char(1420,17))). -user:metta_file_buffer(35,521001736,constant,'get-doc-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1420,19),line_char(1420,31))). -user:metta_file_buffer(35,521001736,variable,_272070,['_atom'=_272070],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1420,32),line_char(1420,37))). -user:metta_file_buffer(34,521001736,indexed(metta_other,['get-doc-atom',_272904]),['get-doc-atom',_272956],['_atom'=_272956],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1420,18),line_char(1420,38))). -user:metta_file_buffer(33,521001736,indexed(metta_other,['Expression',['get-doc-atom',_273494]]),['Expression',['get-doc-atom',_273558]],['_atom'=_273558],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1420,6),line_char(1420,39))). -user:metta_file_buffer(35,522001738,constant,'get-doc-single-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1421,11),line_char(1421,30))). -user:metta_file_buffer(35,522001738,variable,_260880,['_atom'=_260880],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1421,31),line_char(1421,36))). -user:metta_file_buffer(34,522001738,indexed(metta_other,['get-doc-single-atom',_261714]),['get-doc-single-atom',_261766],['_atom'=_261766],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1421,10),line_char(1421,37))). -user:metta_file_buffer(34,523001738,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1421,37),line_char(1421,38))). -user:metta_file_buffer(34,524001738,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1421,39),line_char(1421,40))). -user:metta_file_buffer(34,525001738,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1421,40),line_char(1421,41))). -user:metta_file_buffer(34,526001738,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1421,41),line_char(1421,42))). -user:metta_file_buffer(34,527001738,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1421,42),line_char(1421,43))). -user:metta_file_buffer(35,528001739,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1423,1),line_char(1423,3))). -user:metta_file_buffer(35,528001739,constant,'get-doc-single-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1423,4),line_char(1423,23))). -user:metta_file_buffer(35,528001739,constant,'PrivateRelation',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1423,24),line_char(1423,39))). -user:metta_file_buffer(34,528001739,metta_other,[iz,'get-doc-single-atom','PrivateRelation'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1423,0),line_char(1423,40))). -user:metta_file_buffer(35,529001740,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1424,1),line_char(1424,5))). -user:metta_file_buffer(35,529001740,constant,'get-doc-single-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1424,6),line_char(1424,25))). -user:metta_file_buffer(36,529001741,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1425,3),line_char(1425,8))). -user:metta_file_buffer(36,529001741,string,"Function used by get-doc to get documentation on either function or atom. It checks if input name is the name of function or atom and calls correspondent function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1425,9),line_char(1425,173))). -user:metta_file_buffer(35,529001741,metta_other,['@desc',"Function used by get-doc to get documentation on either function or atom. It checks if input name is the name of function or atom and calls correspondent function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1425,2),line_char(1425,174))). -user:metta_file_buffer(36,529001742,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1426,3),line_char(1426,10))). -user:metta_file_buffer(38,529001744,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1427,5),line_char(1427,11))). -user:metta_file_buffer(38,529001744,string,"Atom/Function name for which documentation is needed",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1427,12),line_char(1427,66))). -user:metta_file_buffer(37,529001744,metta_other,['@param',"Atom/Function name for which documentation is needed"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1427,4),line_char(1427,67))). -user:metta_file_buffer(36,529001744,array,[['@param',"Atom/Function name for which documentation is needed"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1426,11),line_char(1427,68))). -user:metta_file_buffer(35,529001744,metta_other,['@params',[['@param',"Atom/Function name for which documentation is needed"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1426,2),line_char(1427,69))). -user:metta_file_buffer(36,529001745,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1428,3),line_char(1428,10))). -user:metta_file_buffer(36,529001745,string,"Documentation for the given atom/function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1428,11),line_char(1428,54))). -user:metta_file_buffer(35,529001745,metta_other,['@return',"Documentation for the given atom/function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1428,2),line_char(1428,55))). -user:metta_file_buffer(34,529001745,metta_other,['@doc','get-doc-single-atom',['@desc',"Function used by get-doc to get documentation on either function or atom. It checks if input name is the name of function or atom and calls correspondent function"],['@params',[['@param',"Atom/Function name for which documentation is needed"]]],['@return',"Documentation for the given atom/function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1424,0),line_char(1428,56))). -user:metta_file_buffer(35,530001746,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1429,1),line_char(1429,2))). -user:metta_file_buffer(35,530001746,constant,'get-doc-single-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1429,3),line_char(1429,22))). -user:metta_file_buffer(36,530001747,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1429,24),line_char(1429,26))). -user:metta_file_buffer(36,530001747,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1429,27),line_char(1429,31))). -user:metta_file_buffer(36,530001747,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1429,32),line_char(1429,36))). -user:metta_file_buffer(35,530001747,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1429,23),line_char(1429,37))). -user:metta_file_buffer(34,530001747,metta_typedecl,[:,'get-doc-single-atom',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1429,0),line_char(1429,38))). -user:metta_file_buffer(35,531001748,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1430,1),line_char(1430,2))). -user:metta_file_buffer(36,531001749,constant,'get-doc-single-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1430,4),line_char(1430,23))). -user:metta_file_buffer(36,531001749,variable,_263230,['_atom'=_263230],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1430,24),line_char(1430,29))). -user:metta_file_buffer(35,531001749,indexed(metta_other,['get-doc-single-atom',_264064]),['get-doc-single-atom',_264116],['_atom'=_264116],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1430,3),line_char(1430,30))). -user:metta_file_buffer(36,531001750,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1431,3),line_char(1431,6))). -user:metta_file_buffer(36,531001750,variable,_265978,['_top_space'=_265978],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1431,7),line_char(1431,17))). -user:metta_file_buffer(37,531001751,constant,'mod-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1431,19),line_char(1431,29))). -user:metta_file_buffer(37,531001751,constant,top,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1431,30),line_char(1431,33))). -user:metta_file_buffer(36,531001751,metta_directive,['mod-space!',top],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1431,18),line_char(1431,34))). -user:metta_file_buffer(37,531001752,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1432,3),line_char(1432,6))). -user:metta_file_buffer(37,531001752,variable,_270142,['_type'=_270142],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1432,7),line_char(1432,12))). -user:metta_file_buffer(38,531001753,constant,'get-type-space',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1432,14),line_char(1432,28))). -user:metta_file_buffer(38,531001753,variable,_272354,['_top_space'=_272354],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1432,29),line_char(1432,39))). -user:metta_file_buffer(38,531001753,variable,_273646,['_atom'=_273646],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1432,40),line_char(1432,45))). -user:metta_file_buffer(37,531001753,indexed(metta_other,['get-type-space',_274486,_274508]),['get-type-space',_274560,_274566],['_atom'=_274566,'_top_space'=_274560],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1432,13),line_char(1432,46))). -user:metta_file_buffer(38,531001754,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1433,5),line_char(1433,7))). -user:metta_file_buffer(39,531001755,constant,'is-function-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1433,9),line_char(1433,25))). -user:metta_file_buffer(39,531001755,variable,_277186,['_type'=_277186],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1433,26),line_char(1433,31))). -user:metta_file_buffer(38,531001755,indexed(metta_other,['is-function-type',_278020]),['is-function-type',_278072],['_type'=_278072],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1433,8),line_char(1433,32))). -user:metta_file_buffer(39,531001756,constant,'get-doc-function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1434,7),line_char(1434,23))). -user:metta_file_buffer(39,531001756,variable,_279902,['_atom'=_279902],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1434,24),line_char(1434,29))). -user:metta_file_buffer(39,531001756,variable,_281194,['_type'=_281194],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1434,30),line_char(1434,35))). -user:metta_file_buffer(38,531001756,indexed(metta_other,['get-doc-function',_282034,_282056]),['get-doc-function',_282108,_282114],['_type'=_282114,'_atom'=_282108],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1434,6),line_char(1434,36))). -user:metta_file_buffer(39,531001757,constant,'get-doc-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1435,7),line_char(1435,19))). -user:metta_file_buffer(39,531001757,variable,_283924,['_atom'=_283924],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1435,20),line_char(1435,25))). -user:metta_file_buffer(38,531001757,indexed(metta_other,['get-doc-atom',_284758]),['get-doc-atom',_284810],['_atom'=_284810],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1435,6),line_char(1435,26))). -user:metta_file_buffer(37,531001757,indexed(metta_other,[if,['is-function-type',_285362],['get-doc-function',_285400,_285362],['get-doc-atom',_285400]]),[if,['is-function-type',_285516],['get-doc-function',_285534,_285516],['get-doc-atom',_285534]],['_atom'=_285534,'_type'=_285516],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1433,4),line_char(1435,28))). -user:metta_file_buffer(36,531001757,indexed(metta_other,[let,_286104,['get-type-space',_286142,_286164],[if,['is-function-type',_286104],['get-doc-function',_286164,_286104],['get-doc-atom',_286164]]]),[let,_286352,['get-type-space',_286370,_286376],[if,['is-function-type',_286352],['get-doc-function',_286376,_286352],['get-doc-atom',_286376]]],['_atom'=_286376,'_top_space'=_286370,'_type'=_286352],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1432,2),line_char(1435,29))). -user:metta_file_buffer(35,531001757,indexed(metta_other,[let,_287006,['mod-space!',top],[let,_287068,['get-type-space',_287006,_287124],[if,['is-function-type',_287068],['get-doc-function',_287124,_287068],['get-doc-atom',_287124]]]]),[let,_287312,['mod-space!',top],[let,_287336,['get-type-space',_287312,_287360],[if,['is-function-type',_287336],['get-doc-function',_287360,_287336],['get-doc-atom',_287360]]]],['_atom'=_287360,'_type'=_287336,'_top_space'=_287312],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1431,2),line_char(1435,30))). -user:metta_file_buffer(34,531001757,indexed(metta_defun,['get-doc-single-atom',_288000]),[=,['get-doc-single-atom',_288352],[let,_288370,['mod-space!',top],[let,_288394,['get-type-space',_288370,_288352],[if,['is-function-type',_288394],['get-doc-function',_288352,_288394],['get-doc-atom',_288352]]]]],['_type'=_288394,'_top_space'=_288370,'_atom'=_288352],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1430,0),line_char(1435,31))). -user:metta_file_buffer(35,532001758,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1437,1),line_char(1437,3))). -user:metta_file_buffer(35,532001758,constant,'get-doc-function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1437,4),line_char(1437,20))). -user:metta_file_buffer(35,532001758,constant,'PrivateRelation',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1437,21),line_char(1437,36))). -user:metta_file_buffer(34,532001758,metta_other,[iz,'get-doc-function','PrivateRelation'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1437,0),line_char(1437,37))). -user:metta_file_buffer(35,533001759,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1438,1),line_char(1438,5))). -user:metta_file_buffer(35,533001759,constant,'get-doc-function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1438,6),line_char(1438,22))). -user:metta_file_buffer(36,533001760,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1439,3),line_char(1439,8))). -user:metta_file_buffer(36,533001760,string,"Function used by get-doc-single-atom to get documentation on a function. It returns documentation on a function if it exists or default documentation with no description otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1439,9),line_char(1439,190))). -user:metta_file_buffer(35,533001760,metta_other,['@desc',"Function used by get-doc-single-atom to get documentation on a function. It returns documentation on a function if it exists or default documentation with no description otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1439,2),line_char(1439,191))). -user:metta_file_buffer(36,533001761,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1440,3),line_char(1440,10))). -user:metta_file_buffer(38,533001763,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1441,5),line_char(1441,11))). -user:metta_file_buffer(38,533001763,string,"Function name for which documentation is needed",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1441,12),line_char(1441,61))). -user:metta_file_buffer(37,533001763,metta_other,['@param',"Function name for which documentation is needed"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1441,4),line_char(1441,62))). -user:metta_file_buffer(38,533001764,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1442,5),line_char(1442,11))). -user:metta_file_buffer(38,533001764,string,"Type notation for this function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1442,12),line_char(1442,45))). -user:metta_file_buffer(37,533001764,metta_other,['@param',"Type notation for this function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1442,4),line_char(1442,46))). -user:metta_file_buffer(36,533001764,array,[['@param',"Function name for which documentation is needed"],['@param',"Type notation for this function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1440,11),line_char(1442,47))). -user:metta_file_buffer(35,533001764,metta_other,['@params',[['@param',"Function name for which documentation is needed"],['@param',"Type notation for this function"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1440,2),line_char(1442,48))). -user:metta_file_buffer(36,533001765,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1443,3),line_char(1443,10))). -user:metta_file_buffer(36,533001765,string,"Documentation for the given function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1443,11),line_char(1443,49))). -user:metta_file_buffer(35,533001765,metta_other,['@return',"Documentation for the given function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1443,2),line_char(1443,50))). -user:metta_file_buffer(34,533001765,metta_other,['@doc','get-doc-function',['@desc',"Function used by get-doc-single-atom to get documentation on a function. It returns documentation on a function if it exists or default documentation with no description otherwise"],['@params',[['@param',"Function name for which documentation is needed"],['@param',"Type notation for this function"]]],['@return',"Documentation for the given function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1438,0),line_char(1443,51))). -user:metta_file_buffer(35,534001766,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1444,1),line_char(1444,2))). -user:metta_file_buffer(35,534001766,constant,'get-doc-function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1444,3),line_char(1444,19))). -user:metta_file_buffer(36,534001767,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1444,21),line_char(1444,23))). -user:metta_file_buffer(36,534001767,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1444,24),line_char(1444,28))). -user:metta_file_buffer(36,534001767,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1444,29),line_char(1444,33))). -user:metta_file_buffer(36,534001767,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1444,34),line_char(1444,38))). -user:metta_file_buffer(35,534001767,metta_other,[->,'Atom','Type','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1444,20),line_char(1444,39))). -user:metta_file_buffer(34,534001767,metta_typedecl,[:,'get-doc-function',[->,'Atom','Type','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1444,0),line_char(1444,40))). -user:metta_file_buffer(35,535001768,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1445,1),line_char(1445,2))). -user:metta_file_buffer(36,535001769,constant,'get-doc-function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1445,4),line_char(1445,20))). -user:metta_file_buffer(36,535001769,variable,_269416,['_name'=_269416],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1445,21),line_char(1445,26))). -user:metta_file_buffer(36,535001769,variable,_270708,['_type'=_270708],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1445,27),line_char(1445,32))). -user:metta_file_buffer(35,535001769,indexed(metta_other,['get-doc-function',_271548,_271570]),['get-doc-function',_271622,_271628],['_type'=_271628,'_name'=_271622],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1445,3),line_char(1445,33))). -user:metta_file_buffer(36,535001770,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1446,3),line_char(1446,6))). -user:metta_file_buffer(36,535001770,variable,_273502,['_top_space'=_273502],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1446,7),line_char(1446,17))). -user:metta_file_buffer(37,535001771,constant,'mod-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1446,19),line_char(1446,29))). -user:metta_file_buffer(37,535001771,constant,top,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1446,30),line_char(1446,33))). -user:metta_file_buffer(36,535001771,metta_directive,['mod-space!',top],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1446,18),line_char(1446,34))). -user:metta_file_buffer(37,535001772,constant,unify,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1447,3),line_char(1447,8))). -user:metta_file_buffer(37,535001772,variable,_277788,['_top_space'=_277788],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1447,9),line_char(1447,19))). -user:metta_file_buffer(38,535001773,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1447,21),line_char(1447,25))). -user:metta_file_buffer(38,535001773,variable,_279798,['_name'=_279798],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1447,26),line_char(1447,31))). -user:metta_file_buffer(38,535001773,variable,_281082,['_desc'=_281082],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1447,32),line_char(1447,37))). -user:metta_file_buffer(39,535001774,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1447,39),line_char(1447,46))). -user:metta_file_buffer(39,535001774,variable,_283178,['_params'=_283178],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1447,47),line_char(1447,54))). -user:metta_file_buffer(38,535001774,indexed(metta_other,['@params',_284012]),['@params',_284064],['_params'=_284064],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1447,38),line_char(1447,55))). -user:metta_file_buffer(38,535001774,variable,_285028,['_ret'=_285028],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1447,56),line_char(1447,60))). -user:metta_file_buffer(37,535001774,indexed(metta_other,['@doc',_285880,_285902,['@params',_285940],_285962]),['@doc',_286014,_286020,['@params',_286038],_286044],['_ret'=_286044,'_params'=_286038,'_desc'=_286020,'_name'=_286014],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1447,20),line_char(1447,61))). -user:metta_file_buffer(38,535001775,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,5),line_char(1448,8))). -user:metta_file_buffer(39,536001776,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,17),line_char(1448,19))). -user:metta_file_buffer(40,536001777,constant,==,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,21),line_char(1448,23))). -user:metta_file_buffer(40,536001777,variable,_290310,['_type'=_290310],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,24),line_char(1448,29))). -user:metta_file_buffer(40,536001777,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,30),line_char(1448,41))). -user:metta_file_buffer(39,536001777,indexed(metta_other,[==,_291924,'%Undefined%']),[==,_291984,'%Undefined%'],['_type'=_291984],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,20),line_char(1448,42))). -user:metta_file_buffer(40,536001778,constant,'undefined-doc-function-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,44),line_char(1448,71))). -user:metta_file_buffer(40,536001778,variable,_293968,['_params'=_293968],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,72),line_char(1448,79))). -user:metta_file_buffer(39,536001778,indexed(metta_other,['undefined-doc-function-type',_294802]),['undefined-doc-function-type',_294854],['_params'=_294854],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,43),line_char(1448,80))). -user:metta_file_buffer(40,536001779,constant,'cdr-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,82),line_char(1448,90))). -user:metta_file_buffer(40,536001779,variable,_296600,['_type'=_296600],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,91),line_char(1448,96))). -user:metta_file_buffer(39,536001779,indexed(metta_other,['cdr-atom',_297434]),['cdr-atom',_297486],['_type'=_297486],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,81),line_char(1448,97))). -user:metta_file_buffer(38,536001779,indexed(metta_other,[if,[==,_298036,'%Undefined%'],['undefined-doc-function-type',_298082],['cdr-atom',_298036]]),[if,[==,_298180,'%Undefined%'],['undefined-doc-function-type',_298198],['cdr-atom',_298180]],['_params'=_298198,'_type'=_298180],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1448,16),line_char(1448,98))). -user:metta_file_buffer(39,537001780,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1449,5),line_char(1449,8))). -user:metta_file_buffer(40,539001781,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1449,24),line_char(1449,25))). -user:metta_file_buffer(41,540001782,constant,'get-doc-params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1449,27),line_char(1449,41))). -user:metta_file_buffer(41,540001782,variable,_296006,['_params'=_296006],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1449,42),line_char(1449,49))). -user:metta_file_buffer(41,540001782,variable,_297274,['_ret'=_297274],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1449,50),line_char(1449,54))). -user:metta_file_buffer(41,541001782,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1449,61),line_char(1449,62))). -user:metta_file_buffer(42,542001783,constant,'@doc-formal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,7),line_char(1450,18))). -user:metta_file_buffer(43,542001784,constant,'@item',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,20),line_char(1450,25))). -user:metta_file_buffer(43,542001784,variable,_301348,['_name'=_301348],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,26),line_char(1450,31))). -user:metta_file_buffer(42,542001784,indexed(metta_other,['@item',_302182]),['@item',_302234],['_name'=_302234],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,19),line_char(1450,32))). -user:metta_file_buffer(43,542001785,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,34),line_char(1450,39))). -user:metta_file_buffer(43,542001785,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,40),line_char(1450,48))). -user:metta_file_buffer(42,542001785,metta_other,['@kind',function],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,33),line_char(1450,49))). -user:metta_file_buffer(43,542001786,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,51),line_char(1450,56))). -user:metta_file_buffer(43,542001786,variable,_305926,['_type'=_305926],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,57),line_char(1450,62))). -user:metta_file_buffer(42,542001786,indexed(metta_other,['@type',_306760]),['@type',_306812],['_type'=_306812],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,50),line_char(1450,63))). -user:metta_file_buffer(42,542001786,variable,_307784,['_desc'=_307784],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,64),line_char(1450,69))). -user:metta_file_buffer(43,542001787,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,71),line_char(1450,78))). -user:metta_file_buffer(43,543001787,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,87),line_char(1450,88))). -user:metta_file_buffer(43,545001787,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,94),line_char(1450,95))). -user:metta_file_buffer(43,546001787,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,95),line_char(1450,96))). -user:metta_file_buffer(43,547001787,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1450,96),line_char(1450,97))). -user:metta_file_buffer(44,548001788,constant,'@doc-formal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,5),line_char(1451,16))). -user:metta_file_buffer(45,548001789,constant,'@item',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,18),line_char(1451,23))). -user:metta_file_buffer(45,548001789,variable,_314518,['_name'=_314518],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,24),line_char(1451,29))). -user:metta_file_buffer(44,548001789,indexed(metta_other,['@item',_315352]),['@item',_315404],['_name'=_315404],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,17),line_char(1451,30))). -user:metta_file_buffer(45,548001790,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,32),line_char(1451,37))). -user:metta_file_buffer(45,548001790,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,38),line_char(1451,46))). -user:metta_file_buffer(44,548001790,metta_other,['@kind',function],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,31),line_char(1451,47))). -user:metta_file_buffer(45,548001791,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,49),line_char(1451,54))). -user:metta_file_buffer(45,548001791,variable,_319096,['_type'=_319096],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,55),line_char(1451,60))). -user:metta_file_buffer(44,548001791,indexed(metta_other,['@type',_319930]),['@type',_319982],['_type'=_319982],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,48),line_char(1451,61))). -user:metta_file_buffer(45,548001792,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,63),line_char(1451,68))). -user:metta_file_buffer(45,548001792,string,"No documentation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,69),line_char(1451,87))). -user:metta_file_buffer(44,548001792,metta_other,['@desc',"No documentation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,62),line_char(1451,88))). -user:metta_file_buffer(43,548001792,indexed(metta_other,['@doc-formal',['@item',_322530],['@kind',function],['@type',_322592],['@desc',"No documentation"]]),['@doc-formal',['@item',_322680],['@kind',function],['@type',_322704],['@desc',"No documentation"]],['_type'=_322704,'_name'=_322680],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,4),line_char(1451,89))). -user:metta_file_buffer(43,549001792,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,90),line_char(1451,91))). -user:metta_file_buffer(43,550001792,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,91),line_char(1451,92))). -user:metta_file_buffer(43,551001792,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1451,92),line_char(1451,93))). -user:metta_file_buffer(44,552001793,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1453,1),line_char(1453,3))). -user:metta_file_buffer(44,552001793,constant,'undefined-doc-function-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1453,4),line_char(1453,31))). -user:metta_file_buffer(44,552001793,constant,'PrivateRelation',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1453,32),line_char(1453,47))). -user:metta_file_buffer(43,552001793,metta_other,[iz,'undefined-doc-function-type','PrivateRelation'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1453,0),line_char(1453,48))). -user:metta_file_buffer(44,553001794,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1454,1),line_char(1454,5))). -user:metta_file_buffer(44,553001794,constant,'undefined-doc-function-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1454,6),line_char(1454,33))). -user:metta_file_buffer(45,553001795,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1455,3),line_char(1455,8))). -user:metta_file_buffer(45,553001795,string,"Function used by get-doc-single-atom in case of absence of function's type notation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1455,9),line_char(1455,94))). -user:metta_file_buffer(44,553001795,metta_other,['@desc',"Function used by get-doc-single-atom in case of absence of function's type notation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1455,2),line_char(1455,95))). -user:metta_file_buffer(45,553001796,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1456,3),line_char(1456,10))). -user:metta_file_buffer(47,553001798,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1457,5),line_char(1457,11))). -user:metta_file_buffer(47,553001798,string,"List of parameters for the function we want to get documentation for",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1457,12),line_char(1457,82))). -user:metta_file_buffer(46,553001798,metta_other,['@param',"List of parameters for the function we want to get documentation for"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1457,4),line_char(1457,83))). -user:metta_file_buffer(45,553001798,array,[['@param',"List of parameters for the function we want to get documentation for"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1456,11),line_char(1457,84))). -user:metta_file_buffer(44,553001798,metta_other,['@params',[['@param',"List of parameters for the function we want to get documentation for"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1456,2),line_char(1457,85))). -user:metta_file_buffer(45,553001799,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1458,3),line_char(1458,10))). -user:metta_file_buffer(45,553001799,string,"List of %Undefined% number of which depends on input list size. So for two parameters function will return (%Undefined% %Undefined% %Undefined%)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1458,11),line_char(1458,157))). -user:metta_file_buffer(44,553001799,metta_other,['@return',"List of %Undefined% number of which depends on input list size. So for two parameters function will return (%Undefined% %Undefined% %Undefined%)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1458,2),line_char(1458,158))). -user:metta_file_buffer(43,553001799,metta_other,['@doc','undefined-doc-function-type',['@desc',"Function used by get-doc-single-atom in case of absence of function's type notation"],['@params',[['@param',"List of parameters for the function we want to get documentation for"]]],['@return',"List of %Undefined% number of which depends on input list size. So for two parameters function will return (%Undefined% %Undefined% %Undefined%)"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1454,0),line_char(1458,159))). -user:metta_file_buffer(44,554001800,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1459,1),line_char(1459,2))). -user:metta_file_buffer(44,554001800,constant,'undefined-doc-function-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1459,3),line_char(1459,30))). -user:metta_file_buffer(45,554001801,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1459,32),line_char(1459,34))). -user:metta_file_buffer(45,554001801,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1459,35),line_char(1459,45))). -user:metta_file_buffer(45,554001801,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1459,46),line_char(1459,50))). -user:metta_file_buffer(44,554001801,metta_other,[->,'Expression','Type'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1459,31),line_char(1459,51))). -user:metta_file_buffer(43,554001801,metta_typedecl,[:,'undefined-doc-function-type',[->,'Expression','Type']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1459,0),line_char(1459,52))). -user:metta_file_buffer(44,555001802,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1460,1),line_char(1460,2))). -user:metta_file_buffer(45,555001803,constant,'undefined-doc-function-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1460,4),line_char(1460,31))). -user:metta_file_buffer(45,555001803,variable,_315700,['_params'=_315700],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1460,32),line_char(1460,39))). -user:metta_file_buffer(44,555001803,indexed(metta_other,['undefined-doc-function-type',_316534]),['undefined-doc-function-type',_316586],['_params'=_316586],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1460,3),line_char(1460,40))). -user:metta_file_buffer(45,555001804,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1461,3),line_char(1461,5))). -user:metta_file_buffer(46,555001805,constant,==,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1461,7),line_char(1461,9))). -user:metta_file_buffer(46,555001806,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1461,10),line_char(1461,12))). -user:metta_file_buffer(46,555001806,variable,_319814,['_params'=_319814],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1461,13),line_char(1461,20))). -user:metta_file_buffer(45,555001806,indexed(metta_other,[==,[],_320662]),[==,[],_320720],['_params'=_320720],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1461,6),line_char(1461,21))). -user:metta_file_buffer(46,555001807,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1461,23),line_char(1461,34))). -user:metta_file_buffer(45,555001807,metta_other,['%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1461,22),line_char(1461,35))). -user:metta_file_buffer(46,555001808,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1462,5),line_char(1462,8))). -user:metta_file_buffer(46,555001808,variable,_324052,['_params_tail'=_324052],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1462,9),line_char(1462,21))). -user:metta_file_buffer(47,555001809,constant,'cdr-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1462,23),line_char(1462,31))). -user:metta_file_buffer(47,555001809,variable,_326158,['_params'=_326158],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1462,32),line_char(1462,39))). -user:metta_file_buffer(46,555001809,indexed(metta_other,['cdr-atom',_326992]),['cdr-atom',_327044],['_params'=_327044],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1462,22),line_char(1462,40))). -user:metta_file_buffer(47,555001810,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1463,5),line_char(1463,8))). -user:metta_file_buffer(47,555001810,variable,_328808,['_tail'=_328808],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1463,9),line_char(1463,14))). -user:metta_file_buffer(48,555001811,constant,'undefined-doc-function-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1463,16),line_char(1463,43))). -user:metta_file_buffer(48,555001811,variable,_331190,['_params_tail'=_331190],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1463,44),line_char(1463,56))). -user:metta_file_buffer(47,555001811,indexed(metta_other,['undefined-doc-function-type',_332024]),['undefined-doc-function-type',_332076],['_params_tail'=_332076],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1463,15),line_char(1463,57))). -user:metta_file_buffer(48,555001812,constant,'cons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1464,7),line_char(1464,16))). -user:metta_file_buffer(48,555001812,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1464,17),line_char(1464,28))). -user:metta_file_buffer(48,555001812,variable,_334610,['_tail'=_334610],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1464,29),line_char(1464,34))). -user:metta_file_buffer(47,555001812,indexed(metta_other,['cons-atom','%Undefined%',_335458]),['cons-atom','%Undefined%',_335516],['_tail'=_335516],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1464,6),line_char(1464,35))). -user:metta_file_buffer(46,555001812,indexed(metta_other,[let,_336052,['undefined-doc-function-type',_336090],['cons-atom','%Undefined%',_336052]]),[let,_336184,['undefined-doc-function-type',_336202],['cons-atom','%Undefined%',_336184]],['_params_tail'=_336202,'_tail'=_336184],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1463,4),line_char(1464,37))). -user:metta_file_buffer(45,555001812,indexed(metta_other,[let,_336772,['cdr-atom',_336810],[let,_336848,['undefined-doc-function-type',_336772],['cons-atom','%Undefined%',_336848]]]),[let,_336976,['cdr-atom',_336994],[let,_337012,['undefined-doc-function-type',_336976],['cons-atom','%Undefined%',_337012]]],['_tail'=_337012,'_params'=_336994,'_params_tail'=_336976],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1462,4),line_char(1464,38))). -user:metta_file_buffer(44,555001812,indexed(metta_other,[if,[==,[],_337636],['%Undefined%'],[let,_337690,['cdr-atom',_337636],[let,_337762,['undefined-doc-function-type',_337690],['cons-atom','%Undefined%',_337762]]]]),[if,[==,[],_337908],['%Undefined%'],[let,_337932,['cdr-atom',_337908],[let,_337968,['undefined-doc-function-type',_337932],['cons-atom','%Undefined%',_337968]]]],['_tail'=_337968,'_params_tail'=_337932,'_params'=_337908],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1461,2),line_char(1464,39))). -user:metta_file_buffer(43,555001812,indexed(metta_defun,['undefined-doc-function-type',_338578]),[=,['undefined-doc-function-type',_338902],[if,[==,[],_338902],['%Undefined%'],[let,_338962,['cdr-atom',_338902],[let,_338998,['undefined-doc-function-type',_338962],['cons-atom','%Undefined%',_338998]]]]],['_tail'=_338998,'_params_tail'=_338962,'_params'=_338902],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1460,0),line_char(1464,40))). -user:metta_file_buffer(44,556001813,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1466,1),line_char(1466,3))). -user:metta_file_buffer(44,556001813,constant,'get-doc-params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1466,4),line_char(1466,18))). -user:metta_file_buffer(44,556001813,constant,'PrivateRelation',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1466,19),line_char(1466,34))). -user:metta_file_buffer(43,556001813,metta_other,[iz,'get-doc-params','PrivateRelation'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1466,0),line_char(1466,35))). -user:metta_file_buffer(44,557001814,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1467,1),line_char(1467,5))). -user:metta_file_buffer(44,557001814,constant,'get-doc-params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1467,6),line_char(1467,20))). -user:metta_file_buffer(45,557001815,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1468,3),line_char(1468,8))). -user:metta_file_buffer(45,557001815,string,"Function used by get-doc-function to get function's parameters documentation (including return value)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1468,9),line_char(1468,112))). -user:metta_file_buffer(44,557001815,metta_other,['@desc',"Function used by get-doc-function to get function's parameters documentation (including return value)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1468,2),line_char(1468,113))). -user:metta_file_buffer(45,557001816,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1469,3),line_char(1469,10))). -user:metta_file_buffer(47,557001818,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1470,5),line_char(1470,11))). -user:metta_file_buffer(47,557001818,string,"List of parameters in form of ((@param Description) (@param Description)...)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1470,12),line_char(1470,90))). -user:metta_file_buffer(46,557001818,metta_other,['@param',"List of parameters in form of ((@param Description) (@param Description)...)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1470,4),line_char(1470,91))). -user:metta_file_buffer(47,557001819,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1471,5),line_char(1471,11))). -user:metta_file_buffer(47,557001819,string,"Return value's description in form of (@return Description)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1471,12),line_char(1471,73))). -user:metta_file_buffer(46,557001819,metta_other,['@param',"Return value's description in form of (@return Description)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1471,4),line_char(1471,74))). -user:metta_file_buffer(47,557001820,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1472,5),line_char(1472,11))). -user:metta_file_buffer(47,557001820,string,"Type notation without -> starting symbol e.g. (Atom Atom Atom)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1472,12),line_char(1472,76))). -user:metta_file_buffer(46,557001820,metta_other,['@param',"Type notation without -> starting symbol e.g. (Atom Atom Atom)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1472,4),line_char(1472,77))). -user:metta_file_buffer(45,557001820,array,[['@param',"List of parameters in form of ((@param Description) (@param Description)...)"],['@param',"Return value's description in form of (@return Description)"],['@param',"Type notation without -> starting symbol e.g. (Atom Atom Atom)"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1469,11),line_char(1472,78))). -user:metta_file_buffer(44,557001820,metta_other,['@params',[['@param',"List of parameters in form of ((@param Description) (@param Description)...)"],['@param',"Return value's description in form of (@return Description)"],['@param',"Type notation without -> starting symbol e.g. (Atom Atom Atom)"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1469,2),line_char(1472,79))). -user:metta_file_buffer(45,557001821,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1473,3),line_char(1473,10))). -user:metta_file_buffer(45,557001821,string,"United list of params and return value each augmented with its type. E.g. (((@param (@type Atom) (@desc Description)) (@param (@type Atom) (@desc Description2))) (@return (@type Atom) (@desc Description)))",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1473,11),line_char(1473,218))). -user:metta_file_buffer(44,557001821,metta_other,['@return',"United list of params and return value each augmented with its type. E.g. (((@param (@type Atom) (@desc Description)) (@param (@type Atom) (@desc Description2))) (@return (@type Atom) (@desc Description)))"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1473,2),line_char(1473,219))). -user:metta_file_buffer(43,557001821,metta_other,['@doc','get-doc-params',['@desc',"Function used by get-doc-function to get function's parameters documentation (including return value)"],['@params',[['@param',"List of parameters in form of ((@param Description) (@param Description)...)"],['@param',"Return value's description in form of (@return Description)"],['@param',"Type notation without -> starting symbol e.g. (Atom Atom Atom)"]]],['@return',"United list of params and return value each augmented with its type. E.g. (((@param (@type Atom) (@desc Description)) (@param (@type Atom) (@desc Description2))) (@return (@type Atom) (@desc Description)))"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1467,0),line_char(1473,220))). -user:metta_file_buffer(44,558001822,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1474,1),line_char(1474,2))). -user:metta_file_buffer(44,558001822,constant,'get-doc-params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1474,3),line_char(1474,17))). -user:metta_file_buffer(45,558001823,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1474,19),line_char(1474,21))). -user:metta_file_buffer(45,558001823,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1474,22),line_char(1474,32))). -user:metta_file_buffer(45,558001823,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1474,33),line_char(1474,37))). -user:metta_file_buffer(45,558001823,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1474,38),line_char(1474,48))). -user:metta_file_buffer(46,558001824,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1474,50),line_char(1474,60))). -user:metta_file_buffer(46,558001824,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1474,61),line_char(1474,65))). -user:metta_file_buffer(45,558001824,metta_other,['Expression','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1474,49),line_char(1474,66))). -user:metta_file_buffer(44,558001824,metta_other,[->,'Expression','Atom','Expression',['Expression','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1474,18),line_char(1474,67))). -user:metta_file_buffer(43,558001824,metta_typedecl,[:,'get-doc-params',[->,'Expression','Atom','Expression',['Expression','Atom']]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1474,0),line_char(1474,68))). -user:metta_file_buffer(44,559001825,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1475,1),line_char(1475,2))). -user:metta_file_buffer(45,559001826,constant,'get-doc-params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1475,4),line_char(1475,18))). -user:metta_file_buffer(45,559001826,variable,_335888,['_params'=_335888],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1475,19),line_char(1475,26))). -user:metta_file_buffer(45,559001826,variable,_337156,['_ret'=_337156],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1475,27),line_char(1475,31))). -user:metta_file_buffer(45,559001826,variable,_338464,['_types'=_338464],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1475,32),line_char(1475,38))). -user:metta_file_buffer(44,559001826,indexed(metta_other,['get-doc-params',_339310,_339332,_339354]),['get-doc-params',_339406,_339412,_339418],['_types'=_339418,'_ret'=_339412,'_params'=_339406],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1475,3),line_char(1475,39))). -user:metta_file_buffer(45,559001827,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1476,3),line_char(1476,6))). -user:metta_file_buffer(45,559001827,variable,_341304,['_head_type'=_341304],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1476,7),line_char(1476,17))). -user:metta_file_buffer(46,559001828,constant,'car-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1476,19),line_char(1476,27))). -user:metta_file_buffer(46,559001828,variable,_343378,['_types'=_343378],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1476,28),line_char(1476,34))). -user:metta_file_buffer(45,559001828,indexed(metta_other,['car-atom',_344212]),['car-atom',_344264],['_types'=_344264],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1476,18),line_char(1476,35))). -user:metta_file_buffer(46,559001829,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1477,3),line_char(1477,6))). -user:metta_file_buffer(46,559001829,variable,_346142,['_tail_types'=_346142],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1477,7),line_char(1477,18))). -user:metta_file_buffer(47,559001830,constant,'cdr-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1477,20),line_char(1477,28))). -user:metta_file_buffer(47,559001830,variable,_348216,['_types'=_348216],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1477,29),line_char(1477,35))). -user:metta_file_buffer(46,559001830,indexed(metta_other,['cdr-atom',_349050]),['cdr-atom',_349102],['_types'=_349102],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1477,19),line_char(1477,36))). -user:metta_file_buffer(47,559001831,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1478,5),line_char(1478,7))). -user:metta_file_buffer(48,559001832,constant,==,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1478,9),line_char(1478,11))). -user:metta_file_buffer(48,559001833,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1478,12),line_char(1478,14))). -user:metta_file_buffer(48,559001833,variable,_352334,['_params'=_352334],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1478,15),line_char(1478,22))). -user:metta_file_buffer(47,559001833,indexed(metta_other,[==,[],_353182]),[==,[],_353240],['_params'=_353240],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1478,8),line_char(1478,23))). -user:metta_file_buffer(48,559001834,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1479,7),line_char(1479,10))). -user:metta_file_buffer(49,559001835,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1479,12),line_char(1479,19))). -user:metta_file_buffer(49,559001835,variable,_355858,['_ret_desc'=_355858],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1479,20),line_char(1479,29))). -user:metta_file_buffer(48,559001835,indexed(metta_other,['@return',_356692]),['@return',_356744],['_ret_desc'=_356744],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1479,11),line_char(1479,30))). -user:metta_file_buffer(48,559001835,variable,_357700,['_ret'=_357700],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1479,31),line_char(1479,35))). -user:metta_file_buffer(49,559001837,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1480,9),line_char(1480,11))). -user:metta_file_buffer(50,559001838,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1480,13),line_char(1480,20))). -user:metta_file_buffer(51,559001839,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1480,22),line_char(1480,27))). -user:metta_file_buffer(51,559001839,variable,_361388,['_head_type'=_361388],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1480,28),line_char(1480,38))). -user:metta_file_buffer(50,559001839,indexed(metta_other,['@type',_362222]),['@type',_362274],['_head_type'=_362274],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1480,21),line_char(1480,39))). -user:metta_file_buffer(51,559001840,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1480,41),line_char(1480,46))). -user:metta_file_buffer(51,559001840,variable,_364076,['_ret_desc'=_364076],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1480,47),line_char(1480,56))). -user:metta_file_buffer(50,559001840,indexed(metta_other,['@desc',_364910]),['@desc',_364962],['_ret_desc'=_364962],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1480,40),line_char(1480,57))). -user:metta_file_buffer(49,559001840,indexed(metta_other,['@return',['@type',_365506],['@desc',_365544]]),['@return',['@type',_365608],['@desc',_365626]],['_ret_desc'=_365626,'_head_type'=_365608],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1480,12),line_char(1480,58))). -user:metta_file_buffer(48,559001840,indexed(metta_other,[[],['@return',['@type',_366192],['@desc',_366230]]]),[[],['@return',['@type',_366306],['@desc',_366324]]],['_ret_desc'=_366324,'_head_type'=_366306],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1480,8),line_char(1480,59))). -user:metta_file_buffer(47,559001840,indexed(metta_other,[let,['@return',_366888],_366910,[[],['@return',['@type',_366980],['@desc',_366888]]]]),[let,['@return',_367078],_367084,[[],['@return',['@type',_367126],['@desc',_367078]]]],['_head_type'=_367126,'_ret'=_367084,'_ret_desc'=_367078],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1479,6),line_char(1480,61))). -user:metta_file_buffer(48,559001841,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1481,7),line_char(1481,10))). -user:metta_file_buffer(49,559001842,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1481,12),line_char(1481,18))). -user:metta_file_buffer(49,559001842,variable,_369808,['_param_desc'=_369808],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1481,19),line_char(1481,30))). -user:metta_file_buffer(48,559001842,indexed(metta_other,['@param',_370642]),['@param',_370694],['_param_desc'=_370694],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1481,11),line_char(1481,31))). -user:metta_file_buffer(49,559001843,constant,'car-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1481,33),line_char(1481,41))). -user:metta_file_buffer(49,559001843,variable,_372488,['_params'=_372488],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1481,42),line_char(1481,49))). -user:metta_file_buffer(48,559001843,indexed(metta_other,['car-atom',_373322]),['car-atom',_373374],['_params'=_373374],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1481,32),line_char(1481,50))). -user:metta_file_buffer(49,559001844,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1482,9),line_char(1482,12))). -user:metta_file_buffer(49,559001844,variable,_375280,['_tail_params'=_375280],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1482,13),line_char(1482,25))). -user:metta_file_buffer(50,559001845,constant,'cdr-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1482,27),line_char(1482,35))). -user:metta_file_buffer(50,559001845,variable,_377386,['_params'=_377386],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1482,36),line_char(1482,43))). -user:metta_file_buffer(49,559001845,indexed(metta_other,['cdr-atom',_378220]),['cdr-atom',_378272],['_params'=_378272],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1482,26),line_char(1482,44))). -user:metta_file_buffer(50,559001846,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1483,9),line_char(1483,12))). -user:metta_file_buffer(51,560001847,variable,_381274,['_result_ret'=_381274],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1483,23),line_char(1483,34))). -user:metta_file_buffer(51,561001847,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1483,34),line_char(1483,35))). -user:metta_file_buffer(52,562001848,constant,'get-doc-params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1483,37),line_char(1483,51))). -user:metta_file_buffer(52,562001848,variable,_382420,['_tail_params'=_382420],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1483,52),line_char(1483,64))). -user:metta_file_buffer(52,562001848,variable,_383688,['_ret'=_383688],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1483,65),line_char(1483,69))). -user:metta_file_buffer(52,562001848,variable,_385098,['_tail_types'=_385098],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1483,70),line_char(1483,81))). -user:metta_file_buffer(51,562001848,indexed(metta_other,['get-doc-params',_385944,_385966,_385988]),['get-doc-params',_386040,_386046,_386052],['_tail_types'=_386052,'_ret'=_386046,'_tail_params'=_386040],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1483,36),line_char(1483,82))). -user:metta_file_buffer(52,563001849,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1484,9),line_char(1484,12))). -user:metta_file_buffer(52,563001849,variable,_382426,['_result_params'=_382426],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1484,13),line_char(1484,27))). -user:metta_file_buffer(53,563001850,constant,'cons-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1484,29),line_char(1484,38))). -user:metta_file_buffer(54,563001851,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1484,40),line_char(1484,46))). -user:metta_file_buffer(55,563001852,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1484,48),line_char(1484,53))). -user:metta_file_buffer(55,563001852,variable,_386078,['_head_type'=_386078],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1484,54),line_char(1484,64))). -user:metta_file_buffer(54,563001852,indexed(metta_other,['@type',_386912]),['@type',_386964],['_head_type'=_386964],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1484,47),line_char(1484,65))). -user:metta_file_buffer(55,563001853,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1484,67),line_char(1484,72))). -user:metta_file_buffer(55,563001853,variable,_388798,['_param_desc'=_388798],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1484,73),line_char(1484,84))). -user:metta_file_buffer(54,563001853,indexed(metta_other,['@desc',_389632]),['@desc',_389684],['_param_desc'=_389684],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1484,66),line_char(1484,85))). -user:metta_file_buffer(53,563001853,indexed(metta_other,['@param',['@type',_390228],['@desc',_390266]]),['@param',['@type',_390330],['@desc',_390348]],['_param_desc'=_390348,'_head_type'=_390330],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1484,39),line_char(1484,86))). -user:metta_file_buffer(53,564001853,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1484,95),line_char(1484,96))). -user:metta_file_buffer(54,565001854,variable,_392942,['_result_params'=_392942],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1485,11),line_char(1485,25))). -user:metta_file_buffer(54,565001854,variable,_394352,['_result_ret'=_394352],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1485,26),line_char(1485,37))). -user:metta_file_buffer(53,565001854,indexed(metta_other,[_395178,_395200]),[_395246,_395252],['_result_ret'=_395252,'_result_params'=_395246],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1485,10),line_char(1485,38))). -user:metta_file_buffer(53,566001854,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1485,39),line_char(1485,40))). -user:metta_file_buffer(53,567001854,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1485,40),line_char(1485,41))). -user:metta_file_buffer(53,568001854,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1485,41),line_char(1485,42))). -user:metta_file_buffer(53,569001854,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1485,42),line_char(1485,43))). -user:metta_file_buffer(53,570001854,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1485,43),line_char(1485,44))). -user:metta_file_buffer(53,571001854,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1485,44),line_char(1485,45))). -user:metta_file_buffer(53,572001854,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1485,45),line_char(1485,46))). -user:metta_file_buffer(53,573001854,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1485,46),line_char(1485,47))). -user:metta_file_buffer(54,574001855,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1487,1),line_char(1487,3))). -user:metta_file_buffer(54,574001855,constant,'get-doc-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1487,4),line_char(1487,16))). -user:metta_file_buffer(54,574001855,constant,'PrivateRelation',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1487,17),line_char(1487,32))). -user:metta_file_buffer(53,574001855,metta_other,[iz,'get-doc-atom','PrivateRelation'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1487,0),line_char(1487,33))). -user:metta_file_buffer(54,575001856,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1488,1),line_char(1488,5))). -user:metta_file_buffer(54,575001856,constant,'get-doc-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1488,6),line_char(1488,18))). -user:metta_file_buffer(55,575001857,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1489,3),line_char(1489,8))). -user:metta_file_buffer(55,575001857,string,"Function used by get-doc (in case of input type Expression) and get-doc-single-atom (in case input value is not a function) to get documentation on input value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1489,9),line_char(1489,170))). -user:metta_file_buffer(54,575001857,metta_other,['@desc',"Function used by get-doc (in case of input type Expression) and get-doc-single-atom (in case input value is not a function) to get documentation on input value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1489,2),line_char(1489,171))). -user:metta_file_buffer(55,575001858,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1490,3),line_char(1490,10))). -user:metta_file_buffer(57,575001860,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1491,5),line_char(1491,11))). -user:metta_file_buffer(57,575001860,string,"Atom's name to get documentation for",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1491,12),line_char(1491,50))). -user:metta_file_buffer(56,575001860,metta_other,['@param',"Atom's name to get documentation for"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1491,4),line_char(1491,51))). -user:metta_file_buffer(55,575001860,array,[['@param',"Atom's name to get documentation for"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1490,11),line_char(1491,52))). -user:metta_file_buffer(54,575001860,metta_other,['@params',[['@param',"Atom's name to get documentation for"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1490,2),line_char(1491,53))). -user:metta_file_buffer(55,575001861,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1492,3),line_char(1492,10))). -user:metta_file_buffer(55,575001861,string,"Documentation on input Atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1492,11),line_char(1492,40))). -user:metta_file_buffer(54,575001861,metta_other,['@return',"Documentation on input Atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1492,2),line_char(1492,41))). -user:metta_file_buffer(53,575001861,metta_other,['@doc','get-doc-atom',['@desc',"Function used by get-doc (in case of input type Expression) and get-doc-single-atom (in case input value is not a function) to get documentation on input value"],['@params',[['@param',"Atom's name to get documentation for"]]],['@return',"Documentation on input Atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1488,0),line_char(1492,42))). -user:metta_file_buffer(54,576001862,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1493,1),line_char(1493,2))). -user:metta_file_buffer(54,576001862,constant,'get-doc-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1493,3),line_char(1493,15))). -user:metta_file_buffer(55,576001863,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1493,17),line_char(1493,19))). -user:metta_file_buffer(55,576001863,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1493,20),line_char(1493,24))). -user:metta_file_buffer(55,576001863,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1493,25),line_char(1493,29))). -user:metta_file_buffer(54,576001863,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1493,16),line_char(1493,30))). -user:metta_file_buffer(53,576001863,metta_typedecl,[:,'get-doc-atom',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1493,0),line_char(1493,31))). -user:metta_file_buffer(54,577001864,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1494,1),line_char(1494,2))). -user:metta_file_buffer(55,577001865,constant,'get-doc-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1494,4),line_char(1494,16))). -user:metta_file_buffer(55,577001865,variable,_396750,['_atom'=_396750],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1494,17),line_char(1494,22))). -user:metta_file_buffer(54,577001865,indexed(metta_other,['get-doc-atom',_397584]),['get-doc-atom',_397636],['_atom'=_397636],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1494,3),line_char(1494,23))). -user:metta_file_buffer(55,577001866,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1495,3),line_char(1495,6))). -user:metta_file_buffer(55,577001866,variable,_399498,['_top_space'=_399498],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1495,7),line_char(1495,17))). -user:metta_file_buffer(56,577001867,constant,'mod-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1495,19),line_char(1495,29))). -user:metta_file_buffer(56,577001867,constant,top,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1495,30),line_char(1495,33))). -user:metta_file_buffer(55,577001867,metta_directive,['mod-space!',top],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1495,18),line_char(1495,34))). -user:metta_file_buffer(56,577001868,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1496,3),line_char(1496,6))). -user:metta_file_buffer(56,577001868,variable,_403662,['_type'=_403662],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1496,7),line_char(1496,12))). -user:metta_file_buffer(57,577001869,constant,'get-type-space',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1496,14),line_char(1496,28))). -user:metta_file_buffer(57,577001869,variable,_405874,['_top_space'=_405874],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1496,29),line_char(1496,39))). -user:metta_file_buffer(57,577001869,variable,_407166,['_atom'=_407166],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1496,40),line_char(1496,45))). -user:metta_file_buffer(56,577001869,indexed(metta_other,['get-type-space',_408006,_408028]),['get-type-space',_408080,_408086],['_atom'=_408086,'_top_space'=_408080],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1496,13),line_char(1496,46))). -user:metta_file_buffer(57,577001870,constant,unify,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1497,5),line_char(1497,10))). -user:metta_file_buffer(57,577001870,variable,_409984,['_top_space'=_409984],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1497,11),line_char(1497,21))). -user:metta_file_buffer(58,577001871,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1497,23),line_char(1497,27))). -user:metta_file_buffer(58,577001871,variable,_411994,['_atom'=_411994],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1497,28),line_char(1497,33))). -user:metta_file_buffer(58,577001871,variable,_413286,['_desc'=_413286],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1497,34),line_char(1497,39))). -user:metta_file_buffer(57,577001871,indexed(metta_other,['@doc',_414126,_414148]),['@doc',_414200,_414206],['_desc'=_414206,'_atom'=_414200],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1497,22),line_char(1497,40))). -user:metta_file_buffer(58,577001872,constant,'@doc-formal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1498,7),line_char(1498,18))). -user:metta_file_buffer(59,577001873,constant,'@item',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1498,20),line_char(1498,25))). -user:metta_file_buffer(59,577001873,variable,_416742,['_atom'=_416742],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1498,26),line_char(1498,31))). -user:metta_file_buffer(58,577001873,indexed(metta_other,['@item',_417576]),['@item',_417628],['_atom'=_417628],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1498,19),line_char(1498,32))). -user:metta_file_buffer(59,577001874,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1498,34),line_char(1498,39))). -user:metta_file_buffer(59,577001874,constant,atom,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1498,40),line_char(1498,44))). -user:metta_file_buffer(58,577001874,metta_other,['@kind',atom],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1498,33),line_char(1498,45))). -user:metta_file_buffer(59,577001875,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1498,47),line_char(1498,52))). -user:metta_file_buffer(59,577001875,variable,_421280,['_type'=_421280],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1498,53),line_char(1498,58))). -user:metta_file_buffer(58,577001875,indexed(metta_other,['@type',_422114]),['@type',_422166],['_type'=_422166],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1498,46),line_char(1498,59))). -user:metta_file_buffer(58,577001875,variable,_423146,['_desc'=_423146],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1498,60),line_char(1498,65))). -user:metta_file_buffer(57,577001875,indexed(metta_other,['@doc-formal',['@item',_424014],['@kind',atom],['@type',_424076],_424098]),['@doc-formal',['@item',_424162],['@kind',atom],['@type',_424186],_424192],['_desc'=_424192,'_type'=_424186,'_atom'=_424162],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1498,6),line_char(1498,66))). -user:metta_file_buffer(58,577001876,constant,unify,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1499,7),line_char(1499,12))). -user:metta_file_buffer(58,577001876,variable,_426106,['_top_space'=_426106],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1499,13),line_char(1499,23))). -user:metta_file_buffer(59,577001877,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1499,25),line_char(1499,29))). -user:metta_file_buffer(59,577001877,variable,_428116,['_atom'=_428116],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1499,30),line_char(1499,35))). -user:metta_file_buffer(60,578001878,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1499,44),line_char(1499,51))). -user:metta_file_buffer(60,578001878,variable,_431130,['_params'=_431130],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1499,52),line_char(1499,59))). -user:metta_file_buffer(59,578001878,indexed(metta_other,['@params',_431964]),['@params',_432016],['_params'=_432016],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1499,43),line_char(1499,60))). -user:metta_file_buffer(59,579001878,variable,_430310,['_ret'=_430310],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1499,61),line_char(1499,65))). -user:metta_file_buffer(59,580001878,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1499,65),line_char(1499,66))). -user:metta_file_buffer(60,581001879,constant,'get-doc-function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1500,9),line_char(1500,25))). -user:metta_file_buffer(60,581001879,variable,_431492,['_atom'=_431492],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1500,26),line_char(1500,31))). -user:metta_file_buffer(60,581001879,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1500,32),line_char(1500,43))). -user:metta_file_buffer(59,581001879,indexed(metta_other,['get-doc-function',_433106,'%Undefined%']),['get-doc-function',_433166,'%Undefined%'],['_atom'=_433166],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1500,8),line_char(1500,44))). -user:metta_file_buffer(60,582001880,constant,'@doc-formal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,9),line_char(1501,20))). -user:metta_file_buffer(61,582001881,constant,'@item',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,22),line_char(1501,27))). -user:metta_file_buffer(61,582001881,variable,_434754,['_atom'=_434754],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,28),line_char(1501,33))). -user:metta_file_buffer(60,582001881,indexed(metta_other,['@item',_435588]),['@item',_435640],['_atom'=_435640],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,21),line_char(1501,34))). -user:metta_file_buffer(61,582001882,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,36),line_char(1501,41))). -user:metta_file_buffer(61,582001882,constant,atom,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,42),line_char(1501,46))). -user:metta_file_buffer(60,582001882,metta_other,['@kind',atom],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,35),line_char(1501,47))). -user:metta_file_buffer(61,582001883,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,49),line_char(1501,54))). -user:metta_file_buffer(61,582001883,variable,_439292,['_type'=_439292],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,55),line_char(1501,60))). -user:metta_file_buffer(60,582001883,indexed(metta_other,['@type',_440126]),['@type',_440178],['_type'=_440178],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,48),line_char(1501,61))). -user:metta_file_buffer(61,582001884,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,63),line_char(1501,68))). -user:metta_file_buffer(61,582001884,string,"No documentation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,69),line_char(1501,87))). -user:metta_file_buffer(60,582001884,metta_other,['@desc',"No documentation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,62),line_char(1501,88))). -user:metta_file_buffer(59,582001884,indexed(metta_other,['@doc-formal',['@item',_442726],['@kind',atom],['@type',_442788],['@desc',"No documentation"]]),['@doc-formal',['@item',_442876],['@kind',atom],['@type',_442900],['@desc',"No documentation"]],['_type'=_442900,'_atom'=_442876],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,8),line_char(1501,89))). -user:metta_file_buffer(59,583001884,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,90),line_char(1501,91))). -user:metta_file_buffer(59,584001884,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,91),line_char(1501,92))). -user:metta_file_buffer(59,585001884,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,92),line_char(1501,93))). -user:metta_file_buffer(59,586001884,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,93),line_char(1501,94))). -user:metta_file_buffer(59,587001884,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1501,94),line_char(1501,95))). -user:metta_file_buffer(60,588001885,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1503,1),line_char(1503,3))). -user:metta_file_buffer(60,588001885,constant,'help!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1503,4),line_char(1503,9))). -user:metta_file_buffer(60,588001885,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1503,10),line_char(1503,15))). -user:metta_file_buffer(59,588001885,metta_other,[iz,'help!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1503,0),line_char(1503,16))). -user:metta_file_buffer(60,589001886,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1504,1),line_char(1504,5))). -user:metta_file_buffer(60,589001886,constant,'help!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1504,6),line_char(1504,11))). -user:metta_file_buffer(61,589001887,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1505,3),line_char(1505,8))). -user:metta_file_buffer(61,589001887,string,"Function prints documentation for the input atom.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1505,9),line_char(1505,60))). -user:metta_file_buffer(60,589001887,metta_other,['@desc',"Function prints documentation for the input atom."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1505,2),line_char(1505,61))). -user:metta_file_buffer(61,589001888,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1506,3),line_char(1506,10))). -user:metta_file_buffer(63,589001890,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1507,5),line_char(1507,11))). -user:metta_file_buffer(63,589001890,string,"Input to get documentation for",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1507,12),line_char(1507,44))). -user:metta_file_buffer(62,589001890,metta_other,['@param',"Input to get documentation for"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1507,4),line_char(1507,45))). -user:metta_file_buffer(61,589001890,array,[['@param',"Input to get documentation for"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1506,11),line_char(1507,46))). -user:metta_file_buffer(60,589001890,metta_other,['@params',[['@param',"Input to get documentation for"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1506,2),line_char(1507,47))). -user:metta_file_buffer(61,589001891,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1508,3),line_char(1508,10))). -user:metta_file_buffer(61,589001891,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1508,11),line_char(1508,22))). -user:metta_file_buffer(60,589001891,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1508,2),line_char(1508,23))). -user:metta_file_buffer(59,589001891,metta_other,['@doc','help!',['@desc',"Function prints documentation for the input atom."],['@params',[['@param',"Input to get documentation for"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1504,0),line_char(1508,24))). -user:metta_file_buffer(60,590001892,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1509,1),line_char(1509,2))). -user:metta_file_buffer(60,590001892,constant,'help!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1509,3),line_char(1509,8))). -user:metta_file_buffer(61,590001893,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1509,10),line_char(1509,12))). -user:metta_file_buffer(61,590001893,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1509,13),line_char(1509,17))). -user:metta_file_buffer(62,590001894,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1509,19),line_char(1509,21))). -user:metta_file_buffer(61,590001894,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1509,18),line_char(1509,22))). -user:metta_file_buffer(60,590001894,metta_other,[->,'Atom',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1509,9),line_char(1509,23))). -user:metta_file_buffer(59,590001894,metta_typedecl,[:,'help!',[->,'Atom',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1509,0),line_char(1509,24))). -user:metta_file_buffer(60,591001895,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1510,1),line_char(1510,2))). -user:metta_file_buffer(60,591001895,constant,'metta-help!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1510,3),line_char(1510,14))). -user:metta_file_buffer(61,591001896,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1510,16),line_char(1510,18))). -user:metta_file_buffer(61,591001896,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1510,19),line_char(1510,23))). -user:metta_file_buffer(62,591001897,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1510,25),line_char(1510,27))). -user:metta_file_buffer(61,591001897,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1510,24),line_char(1510,28))). -user:metta_file_buffer(60,591001897,metta_other,[->,'Atom',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1510,15),line_char(1510,29))). -user:metta_file_buffer(59,591001897,metta_typedecl,[:,'metta-help!',[->,'Atom',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1510,0),line_char(1510,30))). -user:metta_file_buffer(60,592001898,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1511,1),line_char(1511,2))). -user:metta_file_buffer(61,592001899,constant,'metta-help!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1511,4),line_char(1511,15))). -user:metta_file_buffer(61,592001899,variable,_440984,['_atom'=_440984],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1511,16),line_char(1511,21))). -user:metta_file_buffer(60,592001899,indexed(metta_directive,['metta-help!',_441818]),['metta-help!',_441870],['_atom'=_441870],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1511,3),line_char(1511,22))). -user:metta_file_buffer(61,592001900,constant,case,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1512,3),line_char(1512,7))). -user:metta_file_buffer(62,592001901,constant,'get-doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1512,9),line_char(1512,16))). -user:metta_file_buffer(62,592001901,variable,_444410,['_atom'=_444410],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1512,17),line_char(1512,22))). -user:metta_file_buffer(61,592001901,indexed(metta_other,['get-doc',_445244]),['get-doc',_445296],['_atom'=_445296],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1512,8),line_char(1512,23))). -user:metta_file_buffer(64,592001904,constant,'@doc-formal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,6),line_char(1513,17))). -user:metta_file_buffer(65,592001905,constant,'@item',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,19),line_char(1513,24))). -user:metta_file_buffer(65,592001905,variable,_448094,['_item'=_448094],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,25),line_char(1513,30))). -user:metta_file_buffer(64,592001905,indexed(metta_other,['@item',_448928]),['@item',_448980],['_item'=_448980],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,18),line_char(1513,31))). -user:metta_file_buffer(65,592001906,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,33),line_char(1513,38))). -user:metta_file_buffer(65,592001906,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,39),line_char(1513,47))). -user:metta_file_buffer(64,592001906,metta_other,['@kind',function],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,32),line_char(1513,48))). -user:metta_file_buffer(65,592001907,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,50),line_char(1513,55))). -user:metta_file_buffer(65,592001907,variable,_452672,['_type'=_452672],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,56),line_char(1513,61))). -user:metta_file_buffer(64,592001907,indexed(metta_other,['@type',_453506]),['@type',_453558],['_type'=_453558],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,49),line_char(1513,62))). -user:metta_file_buffer(65,592001908,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,64),line_char(1513,69))). -user:metta_file_buffer(65,592001908,variable,_455290,['_descr'=_455290],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,70),line_char(1513,76))). -user:metta_file_buffer(64,592001908,indexed(metta_other,['@desc',_456124]),['@desc',_456176],['_descr'=_456176],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,63),line_char(1513,77))). -user:metta_file_buffer(65,592001909,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1514,18),line_char(1514,25))). -user:metta_file_buffer(65,592001909,variable,_457994,['_params'=_457994],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1514,26),line_char(1514,33))). -user:metta_file_buffer(64,592001909,indexed(metta_other,['@params',_458828]),['@params',_458880],['_params'=_458880],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1514,17),line_char(1514,34))). -user:metta_file_buffer(65,592001910,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1515,18),line_char(1515,25))). -user:metta_file_buffer(66,592001911,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1515,27),line_char(1515,32))). -user:metta_file_buffer(66,592001911,variable,_461472,['_ret_type'=_461472],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1515,33),line_char(1515,42))). -user:metta_file_buffer(65,592001911,indexed(metta_other,['@type',_462306]),['@type',_462358],['_ret_type'=_462358],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1515,26),line_char(1515,43))). -user:metta_file_buffer(66,592001912,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1515,45),line_char(1515,50))). -user:metta_file_buffer(66,592001912,variable,_464160,['_ret_desc'=_464160],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1515,51),line_char(1515,60))). -user:metta_file_buffer(65,592001912,indexed(metta_other,['@desc',_464994]),['@desc',_465046],['_ret_desc'=_465046],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1515,44),line_char(1515,61))). -user:metta_file_buffer(64,592001912,indexed(metta_other,['@return',['@type',_465590],['@desc',_465628]]),['@return',['@type',_465692],['@desc',_465710]],['_ret_desc'=_465710,'_ret_type'=_465692],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1515,17),line_char(1515,62))). -user:metta_file_buffer(63,592001912,indexed(metta_other,['@doc-formal',['@item',_466290],['@kind',function],['@type',_466352],['@desc',_466390],['@params',_466428],['@return',['@type',_466482],['@desc',_466520]]]),['@doc-formal',['@item',_466584],['@kind',function],['@type',_466608],['@desc',_466626],['@params',_466644],['@return',['@type',_466674],['@desc',_466692]]],['_ret_desc'=_466692,'_ret_type'=_466674,'_params'=_466644,'_descr'=_466626,'_type'=_466608,'_item'=_466584],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,5),line_char(1515,63))). -user:metta_file_buffer(64,592001913,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1516,7),line_char(1516,10))). -user:metta_file_buffer(64,592001914,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1516,11),line_char(1516,13))). -user:metta_file_buffer(65,592001915,constant,'println!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1516,15),line_char(1516,23))). -user:metta_file_buffer(66,592001916,constant,'format-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1516,25),line_char(1516,36))). -user:metta_file_buffer(66,592001916,string,"Function {}: {} {}",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1516,37),line_char(1516,57))). -user:metta_file_buffer(67,592001917,variable,_471718,['_item'=_471718],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1516,59),line_char(1516,64))). -user:metta_file_buffer(67,592001917,variable,_473002,['_type'=_473002],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1516,65),line_char(1516,70))). -user:metta_file_buffer(67,592001917,variable,_474310,['_descr'=_474310],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1516,71),line_char(1516,77))). -user:metta_file_buffer(66,592001917,indexed(metta_other,[_475142,_475164,_475186]),[_475232,_475238,_475244],['_descr'=_475244,'_type'=_475238,'_item'=_475232],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1516,58),line_char(1516,78))). -user:metta_file_buffer(65,592001917,indexed(metta_other,['format-args',"Function {}: {} {}",[_475812,_475834,_475856]]),['format-args',"Function {}: {} {}",[_475920,_475926,_475932]],['_descr'=_475932,'_type'=_475926,'_item'=_475920],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1516,24),line_char(1516,79))). -user:metta_file_buffer(64,592001917,indexed(metta_directive,['println!',['format-args',"Function {}: {} {}",[_476510,_476532,_476554]]]),['println!',['format-args',"Function {}: {} {}",[_476630,_476636,_476642]]],['_descr'=_476642,'_type'=_476636,'_item'=_476630],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1516,14),line_char(1516,80))). -user:metta_file_buffer(65,592001918,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1517,7),line_char(1517,10))). -user:metta_file_buffer(65,592001919,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1517,11),line_char(1517,13))). -user:metta_file_buffer(66,592001920,constant,'println!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1517,15),line_char(1517,23))). -user:metta_file_buffer(67,592001921,constant,'format-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1517,25),line_char(1517,36))). -user:metta_file_buffer(67,592001921,string,"Parameters:",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1517,37),line_char(1517,50))). -user:metta_file_buffer(67,592001922,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1517,51),line_char(1517,53))). -user:metta_file_buffer(66,592001922,metta_other,['format-args',"Parameters:",[]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1517,24),line_char(1517,54))). -user:metta_file_buffer(65,592001922,metta_directive,['println!',['format-args',"Parameters:",[]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1517,14),line_char(1517,55))). -user:metta_file_buffer(66,592001923,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1518,7),line_char(1518,10))). -user:metta_file_buffer(66,592001924,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1518,11),line_char(1518,13))). -user:metta_file_buffer(67,592001925,constant,'for-each-in-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1518,15),line_char(1518,31))). -user:metta_file_buffer(67,592001925,variable,_485530,['_params'=_485530],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1518,32),line_char(1518,39))). -user:metta_file_buffer(67,592001925,constant,'help-param!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1518,40),line_char(1518,51))). -user:metta_file_buffer(66,592001925,indexed(metta_other,['for-each-in-atom',_487146,'help-param!']),['for-each-in-atom',_487206,'help-param!'],['_params'=_487206],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1518,14),line_char(1518,52))). -user:metta_file_buffer(67,592001926,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1519,7),line_char(1519,10))). -user:metta_file_buffer(67,592001927,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1519,11),line_char(1519,13))). -user:metta_file_buffer(68,592001928,constant,'println!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1519,15),line_char(1519,23))). -user:metta_file_buffer(69,592001929,constant,'format-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1519,25),line_char(1519,36))). -user:metta_file_buffer(69,592001929,string,"Return: (type {}) {}",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1519,37),line_char(1519,59))). -user:metta_file_buffer(70,592001930,variable,_492278,['_ret_type'=_492278],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1519,61),line_char(1519,70))). -user:metta_file_buffer(70,592001930,variable,_493656,['_ret_desc'=_493656],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1519,71),line_char(1519,80))). -user:metta_file_buffer(69,592001930,indexed(metta_other,[_494482,_494504]),[_494550,_494556],['_ret_desc'=_494556,'_ret_type'=_494550],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1519,60),line_char(1519,81))). -user:metta_file_buffer(68,592001930,indexed(metta_other,['format-args',"Return: (type {}) {}",[_495112,_495134]]),['format-args',"Return: (type {}) {}",[_495198,_495204]],['_ret_desc'=_495204,'_ret_type'=_495198],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1519,24),line_char(1519,82))). -user:metta_file_buffer(67,592001930,indexed(metta_directive,['println!',['format-args',"Return: (type {}) {}",[_495770,_495792]]]),['println!',['format-args',"Return: (type {}) {}",[_495868,_495874]]],['_ret_desc'=_495874,'_ret_type'=_495868],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1519,14),line_char(1519,83))). -user:metta_file_buffer(67,592001931,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1520,6),line_char(1520,8))). -user:metta_file_buffer(66,592001931,indexed(metta_other,[let,[],['println!',['format-args',"Return: (type {}) {}",[_497144,_497166]]],[]]),[let,[],['println!',['format-args',"Return: (type {}) {}",[_497268,_497274]]],[]],['_ret_desc'=_497274,'_ret_type'=_497268],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1519,6),line_char(1520,10))). -user:metta_file_buffer(65,592001931,indexed(metta_other,[let,[],['for-each-in-atom',_497844,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_497946,_497968]]],[]]]),[let,[],['for-each-in-atom',_498046,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_498106,_498112]]],[]]],['_ret_desc'=_498112,'_ret_type'=_498106,'_params'=_498046],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1518,6),line_char(1520,11))). -user:metta_file_buffer(64,592001931,indexed(metta_other,[let,[],['println!',['format-args',"Parameters:",[]]],[let,[],['for-each-in-atom',_498766,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_498868,_498890]]],[]]]]),[let,[],['println!',['format-args',"Parameters:",[]]],[let,[],['for-each-in-atom',_498992,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_499052,_499058]]],[]]]],['_ret_desc'=_499058,'_ret_type'=_499052,'_params'=_498992],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1517,6),line_char(1520,12))). -user:metta_file_buffer(63,592001931,indexed(metta_other,[let,[],['println!',['format-args',"Function {}: {} {}",[_499672,_499694,_499716]]],[let,[],['println!',['format-args',"Parameters:",[]]],[let,[],['for-each-in-atom',_499850,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_499952,_499974]]],[]]]]]),[let,[],['println!',['format-args',"Function {}: {} {}",[_500076,_500082,_500088]]],[let,[],['println!',['format-args',"Parameters:",[]]],[let,[],['for-each-in-atom',_500148,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_500208,_500214]]],[]]]]],['_ret_desc'=_500214,'_ret_type'=_500208,'_params'=_500148,'_descr'=_500088,'_type'=_500082,'_item'=_500076],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1516,6),line_char(1520,13))). -user:metta_file_buffer(62,592001931,indexed(array,[['@doc-formal',['@item',_500820],['@kind',function],['@type',_500882],['@desc',_500920],['@params',_500958],['@return',['@type',_501012],['@desc',_501050]]],[let,[],['println!',['format-args',"Function {}: {} {}",[_500820,_500882,_500920]]],[let,[],['println!',['format-args',"Parameters:",[]]],[let,[],['for-each-in-atom',_500958,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_501012,_501050]]],[]]]]]]),[['@doc-formal',['@item',_501500],['@kind',function],['@type',_501524],['@desc',_501542],['@params',_501560],['@return',['@type',_501590],['@desc',_501608]]],[let,[],['println!',['format-args',"Function {}: {} {}",[_501500,_501524,_501542]]],[let,[],['println!',['format-args',"Parameters:",[]]],[let,[],['for-each-in-atom',_501560,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_501590,_501608]]],[]]]]]],['_ret_desc'=_501608,'_ret_type'=_501590,'_params'=_501560,'_descr'=_501542,'_type'=_501524,'_item'=_501500],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1513,4),line_char(1520,14))). -user:metta_file_buffer(64,592001933,constant,'@doc-formal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,6),line_char(1521,17))). -user:metta_file_buffer(65,592001934,constant,'@item',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,19),line_char(1521,24))). -user:metta_file_buffer(65,592001934,variable,_504530,['_item'=_504530],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,25),line_char(1521,30))). -user:metta_file_buffer(64,592001934,indexed(metta_other,['@item',_505364]),['@item',_505416],['_item'=_505416],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,18),line_char(1521,31))). -user:metta_file_buffer(65,592001935,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,33),line_char(1521,38))). -user:metta_file_buffer(65,592001935,constant,function,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,39),line_char(1521,47))). -user:metta_file_buffer(64,592001935,metta_other,['@kind',function],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,32),line_char(1521,48))). -user:metta_file_buffer(65,592001936,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,50),line_char(1521,55))). -user:metta_file_buffer(65,592001936,variable,_509108,['_type'=_509108],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,56),line_char(1521,61))). -user:metta_file_buffer(64,592001936,indexed(metta_other,['@type',_509942]),['@type',_509994],['_type'=_509994],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,49),line_char(1521,62))). -user:metta_file_buffer(65,592001937,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,64),line_char(1521,69))). -user:metta_file_buffer(65,592001937,variable,_511726,['_descr'=_511726],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,70),line_char(1521,76))). -user:metta_file_buffer(64,592001937,indexed(metta_other,['@desc',_512560]),['@desc',_512612],['_descr'=_512612],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,63),line_char(1521,77))). -user:metta_file_buffer(63,592001937,indexed(metta_other,['@doc-formal',['@item',_513168],['@kind',function],['@type',_513230],['@desc',_513268]]),['@doc-formal',['@item',_513332],['@kind',function],['@type',_513356],['@desc',_513374]],['_descr'=_513374,'_type'=_513356,'_item'=_513332],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,5),line_char(1521,78))). -user:metta_file_buffer(64,592001938,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1522,7),line_char(1522,10))). -user:metta_file_buffer(64,592001939,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1522,11),line_char(1522,13))). -user:metta_file_buffer(65,592001940,constant,'println!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1522,15),line_char(1522,23))). -user:metta_file_buffer(66,592001941,constant,'format-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1522,25),line_char(1522,36))). -user:metta_file_buffer(66,592001941,string,"Function {} (type {}) {}",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1522,37),line_char(1522,63))). -user:metta_file_buffer(67,592001942,variable,_518426,['_item'=_518426],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1522,65),line_char(1522,70))). -user:metta_file_buffer(67,592001942,variable,_519710,['_type'=_519710],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1522,71),line_char(1522,76))). -user:metta_file_buffer(67,592001942,variable,_521018,['_descr'=_521018],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1522,77),line_char(1522,83))). -user:metta_file_buffer(66,592001942,indexed(metta_other,[_521850,_521872,_521894]),[_521940,_521946,_521952],['_descr'=_521952,'_type'=_521946,'_item'=_521940],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1522,64),line_char(1522,84))). -user:metta_file_buffer(65,592001942,indexed(metta_other,['format-args',"Function {} (type {}) {}",[_522520,_522542,_522564]]),['format-args',"Function {} (type {}) {}",[_522628,_522634,_522640]],['_descr'=_522640,'_type'=_522634,'_item'=_522628],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1522,24),line_char(1522,85))). -user:metta_file_buffer(64,592001942,indexed(metta_directive,['println!',['format-args',"Function {} (type {}) {}",[_523218,_523240,_523262]]]),['println!',['format-args',"Function {} (type {}) {}",[_523338,_523344,_523350]]],['_descr'=_523350,'_type'=_523344,'_item'=_523338],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1522,14),line_char(1522,86))). -user:metta_file_buffer(64,592001943,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1523,6),line_char(1523,8))). -user:metta_file_buffer(63,592001943,indexed(metta_other,[let,[],['println!',['format-args',"Function {} (type {}) {}",[_524632,_524654,_524676]]],[]]),[let,[],['println!',['format-args',"Function {} (type {}) {}",[_524778,_524784,_524790]]],[]],['_descr'=_524790,'_type'=_524784,'_item'=_524778],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1522,6),line_char(1523,10))). -user:metta_file_buffer(62,592001943,indexed(array,[['@doc-formal',['@item',_525360],['@kind',function],['@type',_525422],['@desc',_525460]],[let,[],['println!',['format-args',"Function {} (type {}) {}",[_525360,_525422,_525460]]],[]]]),[['@doc-formal',['@item',_525664],['@kind',function],['@type',_525688],['@desc',_525706]],[let,[],['println!',['format-args',"Function {} (type {}) {}",[_525664,_525688,_525706]]],[]]],['_descr'=_525706,'_type'=_525688,'_item'=_525664],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1521,4),line_char(1523,11))). -user:metta_file_buffer(64,592001945,constant,'@doc-formal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,6),line_char(1524,17))). -user:metta_file_buffer(65,592001946,constant,'@item',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,19),line_char(1524,24))). -user:metta_file_buffer(65,592001946,variable,_528466,['_item'=_528466],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,25),line_char(1524,30))). -user:metta_file_buffer(64,592001946,indexed(metta_other,['@item',_529300]),['@item',_529352],['_item'=_529352],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,18),line_char(1524,31))). -user:metta_file_buffer(65,592001947,constant,'@kind',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,33),line_char(1524,38))). -user:metta_file_buffer(65,592001947,constant,atom,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,39),line_char(1524,43))). -user:metta_file_buffer(64,592001947,metta_other,['@kind',atom],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,32),line_char(1524,44))). -user:metta_file_buffer(65,592001948,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,46),line_char(1524,51))). -user:metta_file_buffer(65,592001948,variable,_533004,['_type'=_533004],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,52),line_char(1524,57))). -user:metta_file_buffer(64,592001948,indexed(metta_other,['@type',_533838]),['@type',_533890],['_type'=_533890],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,45),line_char(1524,58))). -user:metta_file_buffer(65,592001949,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,60),line_char(1524,65))). -user:metta_file_buffer(65,592001949,variable,_535622,['_descr'=_535622],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,66),line_char(1524,72))). -user:metta_file_buffer(64,592001949,indexed(metta_other,['@desc',_536456]),['@desc',_536508],['_descr'=_536508],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,59),line_char(1524,73))). -user:metta_file_buffer(63,592001949,indexed(metta_other,['@doc-formal',['@item',_537064],['@kind',atom],['@type',_537126],['@desc',_537164]]),['@doc-formal',['@item',_537228],['@kind',atom],['@type',_537252],['@desc',_537270]],['_descr'=_537270,'_type'=_537252,'_item'=_537228],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,5),line_char(1524,74))). -user:metta_file_buffer(64,592001950,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1525,7),line_char(1525,10))). -user:metta_file_buffer(64,592001951,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1525,11),line_char(1525,13))). -user:metta_file_buffer(65,592001952,constant,'println!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1525,15),line_char(1525,23))). -user:metta_file_buffer(66,592001953,constant,'format-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1525,25),line_char(1525,36))). -user:metta_file_buffer(66,592001953,string,"Atom {}: {} {}",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1525,37),line_char(1525,53))). -user:metta_file_buffer(67,592001954,variable,_542218,['_item'=_542218],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1525,55),line_char(1525,60))). -user:metta_file_buffer(67,592001954,variable,_543502,['_type'=_543502],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1525,61),line_char(1525,66))). -user:metta_file_buffer(67,592001954,variable,_544810,['_descr'=_544810],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1525,67),line_char(1525,73))). -user:metta_file_buffer(66,592001954,indexed(metta_other,[_545642,_545664,_545686]),[_545732,_545738,_545744],['_descr'=_545744,'_type'=_545738,'_item'=_545732],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1525,54),line_char(1525,74))). -user:metta_file_buffer(65,592001954,indexed(metta_other,['format-args',"Atom {}: {} {}",[_546312,_546334,_546356]]),['format-args',"Atom {}: {} {}",[_546420,_546426,_546432]],['_descr'=_546432,'_type'=_546426,'_item'=_546420],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1525,24),line_char(1525,75))). -user:metta_file_buffer(64,592001954,indexed(metta_directive,['println!',['format-args',"Atom {}: {} {}",[_547010,_547032,_547054]]]),['println!',['format-args',"Atom {}: {} {}",[_547130,_547136,_547142]]],['_descr'=_547142,'_type'=_547136,'_item'=_547130],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1525,14),line_char(1525,76))). -user:metta_file_buffer(64,592001955,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1526,6),line_char(1526,8))). -user:metta_file_buffer(63,592001955,indexed(metta_other,[let,[],['println!',['format-args',"Atom {}: {} {}",[_548424,_548446,_548468]]],[]]),[let,[],['println!',['format-args',"Atom {}: {} {}",[_548570,_548576,_548582]]],[]],['_descr'=_548582,'_type'=_548576,'_item'=_548570],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1525,6),line_char(1526,10))). -user:metta_file_buffer(62,592001955,indexed(array,[['@doc-formal',['@item',_549152],['@kind',atom],['@type',_549214],['@desc',_549252]],[let,[],['println!',['format-args',"Atom {}: {} {}",[_549152,_549214,_549252]]],[]]]),[['@doc-formal',['@item',_549456],['@kind',atom],['@type',_549480],['@desc',_549498]],[let,[],['println!',['format-args',"Atom {}: {} {}",[_549456,_549480,_549498]]],[]]],['_descr'=_549498,'_type'=_549480,'_item'=_549456],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1524,4),line_char(1526,11))). -user:metta_file_buffer(63,592001956,variable,_550734,['_other'=_550734],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1527,5),line_char(1527,11))). -user:metta_file_buffer(64,592001957,constant,'Error',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1527,13),line_char(1527,18))). -user:metta_file_buffer(64,592001957,variable,_552770,['_other'=_552770],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1527,19),line_char(1527,25))). -user:metta_file_buffer(64,592001957,string,"Cannot match @doc-formal structure",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1527,26),line_char(1527,62))). -user:metta_file_buffer(63,592001957,indexed(metta_other,['Error',_554514,"Cannot match @doc-formal structure"]),['Error',_554574,"Cannot match @doc-formal structure"],['_other'=_554574],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1527,12),line_char(1527,63))). -user:metta_file_buffer(62,592001957,indexed(metta_other,[_555090,['Error',_555090,"Cannot match @doc-formal structure"]]),[_555178,['Error',_555178,"Cannot match @doc-formal structure"]],['_other'=_555178],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1527,4),line_char(1527,65))). -user:metta_file_buffer(61,592001957,indexed(array,[[['@doc-formal',['@item',_555762],['@kind',function],['@type',_555824],['@desc',_555862],['@params',_555900],['@return',['@type',_555954],['@desc',_555992]]],[let,[],['println!',['format-args',"Function {}: {} {}",[_555762,_555824,_555862]]],[let,[],['println!',['format-args',"Parameters:",[]]],[let,[],['for-each-in-atom',_555900,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_555954,_555992]]],[]]]]]],[['@doc-formal',['@item',_555762],['@kind',function],['@type',_555824],['@desc',_555862]],[let,[],['println!',['format-args',"Function {} (type {}) {}",[_555762,_555824,_555862]]],[]]],[['@doc-formal',['@item',_555762],['@kind',atom],['@type',_555824],['@desc',_555862]],[let,[],['println!',['format-args',"Atom {}: {} {}",[_555762,_555824,_555862]]],[]]],[_556970,['Error',_556970,"Cannot match @doc-formal structure"]]]),[[['@doc-formal',['@item',_557088],['@kind',function],['@type',_557112],['@desc',_557130],['@params',_557148],['@return',['@type',_557178],['@desc',_557196]]],[let,[],['println!',['format-args',"Function {}: {} {}",[_557088,_557112,_557130]]],[let,[],['println!',['format-args',"Parameters:",[]]],[let,[],['for-each-in-atom',_557148,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_557178,_557196]]],[]]]]]],[['@doc-formal',['@item',_557088],['@kind',function],['@type',_557112],['@desc',_557130]],[let,[],['println!',['format-args',"Function {} (type {}) {}",[_557088,_557112,_557130]]],[]]],[['@doc-formal',['@item',_557088],['@kind',atom],['@type',_557112],['@desc',_557130]],[let,[],['println!',['format-args',"Atom {}: {} {}",[_557088,_557112,_557130]]],[]]],[_557706,['Error',_557706,"Cannot match @doc-formal structure"]]],['_other'=_557706,'_ret_desc'=_557196,'_ret_type'=_557178,'_params'=_557148,'_descr'=_557130,'_type'=_557112,'_item'=_557088],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1512,24),line_char(1527,66))). -user:metta_file_buffer(60,592001957,indexed(metta_other,[case,['get-doc',_558346],[[['@doc-formal',['@item',_558416],['@kind',function],['@type',_558478],['@desc',_558516],['@params',_558554],['@return',['@type',_558608],['@desc',_558646]]],[let,[],['println!',['format-args',"Function {}: {} {}",[_558416,_558478,_558516]]],[let,[],['println!',['format-args',"Parameters:",[]]],[let,[],['for-each-in-atom',_558554,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_558608,_558646]]],[]]]]]],[['@doc-formal',['@item',_558416],['@kind',function],['@type',_558478],['@desc',_558516]],[let,[],['println!',['format-args',"Function {} (type {}) {}",[_558416,_558478,_558516]]],[]]],[['@doc-formal',['@item',_558416],['@kind',atom],['@type',_558478],['@desc',_558516]],[let,[],['println!',['format-args',"Atom {}: {} {}",[_558416,_558478,_558516]]],[]]],[_559624,['Error',_559624,"Cannot match @doc-formal structure"]]]]),[case,['get-doc',_559730],[[['@doc-formal',['@item',_559772],['@kind',function],['@type',_559796],['@desc',_559814],['@params',_559832],['@return',['@type',_559862],['@desc',_559880]]],[let,[],['println!',['format-args',"Function {}: {} {}",[_559772,_559796,_559814]]],[let,[],['println!',['format-args',"Parameters:",[]]],[let,[],['for-each-in-atom',_559832,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_559862,_559880]]],[]]]]]],[['@doc-formal',['@item',_559772],['@kind',function],['@type',_559796],['@desc',_559814]],[let,[],['println!',['format-args',"Function {} (type {}) {}",[_559772,_559796,_559814]]],[]]],[['@doc-formal',['@item',_559772],['@kind',atom],['@type',_559796],['@desc',_559814]],[let,[],['println!',['format-args',"Atom {}: {} {}",[_559772,_559796,_559814]]],[]]],[_560390,['Error',_560390,"Cannot match @doc-formal structure"]]]],['_other'=_560390,'_ret_desc'=_559880,'_ret_type'=_559862,'_params'=_559832,'_descr'=_559814,'_type'=_559796,'_item'=_559772,'_atom'=_559730],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1512,2),line_char(1527,67))). -user:metta_file_buffer(59,592001957,indexed(metta_defun,['metta-help!',_561036]),[=,['metta-help!',_562470],[case,['get-doc',_562470],[[['@doc-formal',['@item',_562542],['@kind',function],['@type',_562566],['@desc',_562584],['@params',_562602],['@return',['@type',_562632],['@desc',_562650]]],[let,[],['println!',['format-args',"Function {}: {} {}",[_562542,_562566,_562584]]],[let,[],['println!',['format-args',"Parameters:",[]]],[let,[],['for-each-in-atom',_562602,'help-param!'],[let,[],['println!',['format-args',"Return: (type {}) {}",[_562632,_562650]]],[]]]]]],[['@doc-formal',['@item',_562542],['@kind',function],['@type',_562566],['@desc',_562584]],[let,[],['println!',['format-args',"Function {} (type {}) {}",[_562542,_562566,_562584]]],[]]],[['@doc-formal',['@item',_562542],['@kind',atom],['@type',_562566],['@desc',_562584]],[let,[],['println!',['format-args',"Atom {}: {} {}",[_562542,_562566,_562584]]],[]]],[_563160,['Error',_563160,"Cannot match @doc-formal structure"]]]]],['_other'=_563160,'_ret_desc'=_562650,'_ret_type'=_562632,'_params'=_562602,'_descr'=_562584,'_type'=_562566,'_item'=_562542,'_atom'=_562470],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1511,0),line_char(1527,68))). -user:metta_file_buffer(60,593001958,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1529,1),line_char(1529,3))). -user:metta_file_buffer(60,593001958,constant,'help-param!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1529,4),line_char(1529,15))). -user:metta_file_buffer(60,593001958,constant,'PrivateRelation',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1529,16),line_char(1529,31))). -user:metta_file_buffer(59,593001958,metta_other,[iz,'help-param!','PrivateRelation'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1529,0),line_char(1529,32))). -user:metta_file_buffer(60,594001959,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1530,1),line_char(1530,5))). -user:metta_file_buffer(60,594001959,constant,'help-param!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1530,6),line_char(1530,17))). -user:metta_file_buffer(61,594001960,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1531,3),line_char(1531,8))). -user:metta_file_buffer(61,594001960,string,"Function used by function help! to output parameters using println!",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1531,9),line_char(1531,78))). -user:metta_file_buffer(60,594001960,metta_other,['@desc',"Function used by function help! to output parameters using println!"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1531,2),line_char(1531,79))). -user:metta_file_buffer(61,594001961,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1532,3),line_char(1532,10))). -user:metta_file_buffer(63,594001963,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1533,5),line_char(1533,11))). -user:metta_file_buffer(63,594001963,string,"Parameters list",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1533,12),line_char(1533,29))). -user:metta_file_buffer(62,594001963,metta_other,['@param',"Parameters list"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1533,4),line_char(1533,30))). -user:metta_file_buffer(61,594001963,array,[['@param',"Parameters list"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1532,11),line_char(1533,31))). -user:metta_file_buffer(60,594001963,metta_other,['@params',[['@param',"Parameters list"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1532,2),line_char(1533,32))). -user:metta_file_buffer(61,594001964,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1534,3),line_char(1534,10))). -user:metta_file_buffer(61,594001964,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1534,11),line_char(1534,22))). -user:metta_file_buffer(60,594001964,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1534,2),line_char(1534,23))). -user:metta_file_buffer(59,594001964,metta_other,['@doc','help-param!',['@desc',"Function used by function help! to output parameters using println!"],['@params',[['@param',"Parameters list"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1530,0),line_char(1534,24))). -user:metta_file_buffer(60,595001965,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1535,1),line_char(1535,2))). -user:metta_file_buffer(60,595001965,constant,'help-param!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1535,3),line_char(1535,14))). -user:metta_file_buffer(61,595001966,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1535,16),line_char(1535,18))). -user:metta_file_buffer(61,595001966,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1535,19),line_char(1535,23))). -user:metta_file_buffer(62,595001967,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1535,25),line_char(1535,27))). -user:metta_file_buffer(61,595001967,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1535,24),line_char(1535,28))). -user:metta_file_buffer(60,595001967,metta_other,[->,'Atom',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1535,15),line_char(1535,29))). -user:metta_file_buffer(59,595001967,metta_typedecl,[:,'help-param!',[->,'Atom',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1535,0),line_char(1535,30))). -user:metta_file_buffer(60,596001968,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1536,1),line_char(1536,2))). -user:metta_file_buffer(61,596001969,constant,'help-param!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1536,4),line_char(1536,15))). -user:metta_file_buffer(61,596001969,variable,_545442,['_param'=_545442],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1536,16),line_char(1536,22))). -user:metta_file_buffer(60,596001969,indexed(metta_directive,['help-param!',_546276]),['help-param!',_546328],['_param'=_546328],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1536,3),line_char(1536,23))). -user:metta_file_buffer(61,596001970,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1537,3),line_char(1537,6))). -user:metta_file_buffer(62,596001971,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1537,8),line_char(1537,14))). -user:metta_file_buffer(63,596001972,constant,'@type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1537,16),line_char(1537,21))). -user:metta_file_buffer(63,596001972,variable,_549584,['_type'=_549584],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1537,22),line_char(1537,27))). -user:metta_file_buffer(62,596001972,indexed(metta_other,['@type',_550418]),['@type',_550470],['_type'=_550470],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1537,15),line_char(1537,28))). -user:metta_file_buffer(63,596001973,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1537,30),line_char(1537,35))). -user:metta_file_buffer(63,596001973,variable,_552186,['_desc'=_552186],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1537,36),line_char(1537,41))). -user:metta_file_buffer(62,596001973,indexed(metta_other,['@desc',_553020]),['@desc',_553072],['_desc'=_553072],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1537,29),line_char(1537,42))). -user:metta_file_buffer(61,596001973,indexed(metta_other,['@param',['@type',_553616],['@desc',_553654]]),['@param',['@type',_553718],['@desc',_553736]],['_desc'=_553736,'_type'=_553718],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1537,7),line_char(1537,43))). -user:metta_file_buffer(61,596001973,variable,_554736,['_param'=_554736],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1537,44),line_char(1537,50))). -user:metta_file_buffer(62,596001974,constant,'println!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1538,5),line_char(1538,13))). -user:metta_file_buffer(63,596001975,constant,'format-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1538,15),line_char(1538,26))). -user:metta_file_buffer(63,596001975,string," {} {}",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1538,27),line_char(1538,36))). -user:metta_file_buffer(65,596001977,constant,type,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1538,39),line_char(1538,43))). -user:metta_file_buffer(65,596001977,variable,_559268,['_type'=_559268],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1538,44),line_char(1538,49))). -user:metta_file_buffer(64,596001977,indexed(metta_other,[type,_560102]),[type,_560154],['_type'=_560154],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1538,38),line_char(1538,50))). -user:metta_file_buffer(64,596001977,variable,_561134,['_desc'=_561134],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1538,51),line_char(1538,56))). -user:metta_file_buffer(63,596001977,indexed(array,[[type,_561976],_561998]),[[type,_562056],_562062],['_desc'=_562062,'_type'=_562056],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1538,37),line_char(1538,57))). -user:metta_file_buffer(62,596001977,indexed(metta_other,['format-args'," {} {}",[[type,_562640],_562662]]),['format-args'," {} {}",[[type,_562738],_562744]],['_desc'=_562744,'_type'=_562738],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1538,14),line_char(1538,58))). -user:metta_file_buffer(61,596001977,indexed(metta_directive,['println!',['format-args'," {} {}",[[type,_563326],_563348]]]),['println!',['format-args'," {} {}",[[type,_563436],_563442]]],['_desc'=_563442,'_type'=_563436],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1538,4),line_char(1538,59))). -user:metta_file_buffer(60,596001977,indexed(metta_other,[let,['@param',['@type',_564028],['@desc',_564066]],_564088,['println!',['format-args'," {} {}",[[type,_564028],_564066]]]]),[let,['@param',['@type',_564264],['@desc',_564282]],_564288,['println!',['format-args'," {} {}",[[type,_564264],_564282]]]],['_param'=_564288,'_desc'=_564282,'_type'=_564264],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1537,2),line_char(1538,61))). -user:metta_file_buffer(59,596001977,indexed(metta_defun,['help-param!',_564916]),[=,['help-param!',_565206],[let,['@param',['@type',_565248],['@desc',_565266]],_565206,['println!',['format-args'," {} {}",[[type,_565248],_565266]]]]],['_desc'=_565266,'_type'=_565248,'_param'=_565206],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1536,0),line_char(1538,62))). -user:metta_file_buffer(60,597001978,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1540,1),line_char(1540,3))). -user:metta_file_buffer(60,597001978,constant,'for-each-in-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1540,4),line_char(1540,20))). -user:metta_file_buffer(60,597001978,constant,'PrivateRelation',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1540,21),line_char(1540,36))). -user:metta_file_buffer(59,597001978,metta_other,[iz,'for-each-in-atom','PrivateRelation'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1540,0),line_char(1540,37))). -user:metta_file_buffer(60,598001979,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1541,1),line_char(1541,5))). -user:metta_file_buffer(60,598001979,constant,'for-each-in-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1541,6),line_char(1541,22))). -user:metta_file_buffer(61,598001980,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1542,3),line_char(1542,8))). -user:metta_file_buffer(61,598001980,string,"Applies function passed as a second argument to each atom inside first argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1542,9),line_char(1542,90))). -user:metta_file_buffer(60,598001980,metta_other,['@desc',"Applies function passed as a second argument to each atom inside first argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1542,2),line_char(1542,91))). -user:metta_file_buffer(61,598001981,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1543,3),line_char(1543,10))). -user:metta_file_buffer(63,598001983,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1544,5),line_char(1544,11))). -user:metta_file_buffer(63,598001983,string,"Expression to each atom in which function will be applied",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1544,12),line_char(1544,71))). -user:metta_file_buffer(62,598001983,metta_other,['@param',"Expression to each atom in which function will be applied"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1544,4),line_char(1544,72))). -user:metta_file_buffer(63,598001984,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1545,5),line_char(1545,11))). -user:metta_file_buffer(63,598001984,string,"Function to apply",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1545,12),line_char(1545,31))). -user:metta_file_buffer(62,598001984,metta_other,['@param',"Function to apply"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1545,4),line_char(1545,32))). -user:metta_file_buffer(61,598001984,array,[['@param',"Expression to each atom in which function will be applied"],['@param',"Function to apply"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1543,11),line_char(1545,33))). -user:metta_file_buffer(60,598001984,metta_other,['@params',[['@param',"Expression to each atom in which function will be applied"],['@param',"Function to apply"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1543,2),line_char(1545,34))). -user:metta_file_buffer(61,598001985,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1546,3),line_char(1546,10))). -user:metta_file_buffer(61,598001985,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1546,11),line_char(1546,22))). -user:metta_file_buffer(60,598001985,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1546,2),line_char(1546,23))). -user:metta_file_buffer(59,598001985,metta_other,['@doc','for-each-in-atom',['@desc',"Applies function passed as a second argument to each atom inside first argument"],['@params',[['@param',"Expression to each atom in which function will be applied"],['@param',"Function to apply"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1541,0),line_char(1546,24))). -user:metta_file_buffer(60,599001986,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1547,1),line_char(1547,2))). -user:metta_file_buffer(60,599001986,constant,'for-each-in-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1547,3),line_char(1547,19))). -user:metta_file_buffer(61,599001987,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1547,21),line_char(1547,23))). -user:metta_file_buffer(61,599001987,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1547,24),line_char(1547,34))). -user:metta_file_buffer(61,599001987,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1547,35),line_char(1547,39))). -user:metta_file_buffer(62,599001988,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1547,41),line_char(1547,43))). -user:metta_file_buffer(61,599001988,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1547,40),line_char(1547,44))). -user:metta_file_buffer(60,599001988,metta_other,[->,'Expression','Atom',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1547,20),line_char(1547,45))). -user:metta_file_buffer(59,599001988,metta_typedecl,[:,'for-each-in-atom',[->,'Expression','Atom',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1547,0),line_char(1547,46))). -user:metta_file_buffer(60,600001989,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1548,1),line_char(1548,2))). -user:metta_file_buffer(61,600001990,constant,'for-each-in-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1548,4),line_char(1548,20))). -user:metta_file_buffer(61,600001990,variable,_558162,['_expr'=_558162],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1548,21),line_char(1548,26))). -user:metta_file_buffer(61,600001990,variable,_559454,['_func'=_559454],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1548,27),line_char(1548,32))). -user:metta_file_buffer(60,600001990,indexed(metta_other,['for-each-in-atom',_560294,_560316]),['for-each-in-atom',_560368,_560374],['_func'=_560374,'_expr'=_560368],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1548,3),line_char(1548,33))). -user:metta_file_buffer(61,600001991,constant,if,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1549,3),line_char(1549,5))). -user:metta_file_buffer(62,600001992,constant,'noreduce-eq',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1549,7),line_char(1549,18))). -user:metta_file_buffer(62,600001992,variable,_562932,['_expr'=_562932],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1549,19),line_char(1549,24))). -user:metta_file_buffer(62,600001993,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1549,25),line_char(1549,27))). -user:metta_file_buffer(61,600001993,indexed(metta_other,['noreduce-eq',_564420,[]]),['noreduce-eq',_564480,[]],['_expr'=_564480],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1549,6),line_char(1549,28))). -user:metta_file_buffer(61,600001994,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1550,4),line_char(1550,6))). -user:metta_file_buffer(62,600001995,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1551,5),line_char(1551,8))). -user:metta_file_buffer(62,600001995,variable,_566900,['_head'=_566900],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1551,9),line_char(1551,14))). -user:metta_file_buffer(63,600001996,constant,'car-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1551,16),line_char(1551,24))). -user:metta_file_buffer(63,600001996,variable,_568958,['_expr'=_568958],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1551,25),line_char(1551,30))). -user:metta_file_buffer(62,600001996,indexed(metta_other,['car-atom',_569792]),['car-atom',_569844],['_expr'=_569844],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1551,15),line_char(1551,31))). -user:metta_file_buffer(63,600001997,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1552,7),line_char(1552,10))). -user:metta_file_buffer(63,600001997,variable,_571612,['_tail'=_571612],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1552,11),line_char(1552,16))). -user:metta_file_buffer(64,600001998,constant,'cdr-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1552,18),line_char(1552,26))). -user:metta_file_buffer(64,600001998,variable,_573670,['_expr'=_573670],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1552,27),line_char(1552,32))). -user:metta_file_buffer(63,600001998,indexed(metta_other,['cdr-atom',_574504]),['cdr-atom',_574556],['_expr'=_574556],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1552,17),line_char(1552,33))). -user:metta_file_buffer(64,600001999,constant,let,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1553,7),line_char(1553,10))). -user:metta_file_buffer(65,601002000,variable,_556848,['_func'=_556848],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1553,15),line_char(1553,20))). -user:metta_file_buffer(65,601002000,variable,_558140,['_head'=_558140],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1553,21),line_char(1553,26))). -user:metta_file_buffer(64,601002000,indexed(metta_other,[_558966,_558988]),[_559034,_559040],['_head'=_559040,'_func'=_559034],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1553,14),line_char(1553,27))). -user:metta_file_buffer(65,602002001,constant,'for-each-in-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1554,7),line_char(1554,23))). -user:metta_file_buffer(65,602002001,variable,_557568,['_tail'=_557568],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1554,24),line_char(1554,29))). -user:metta_file_buffer(65,602002001,variable,_558860,['_func'=_558860],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1554,30),line_char(1554,35))). -user:metta_file_buffer(64,602002001,indexed(metta_other,['for-each-in-atom',_559700,_559722]),['for-each-in-atom',_559774,_559780],['_func'=_559780,'_tail'=_559774],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1554,6),line_char(1554,36))). -user:metta_file_buffer(64,603002001,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1554,37),line_char(1554,38))). -user:metta_file_buffer(64,604002001,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1554,38),line_char(1554,39))). -user:metta_file_buffer(64,605002001,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1554,39),line_char(1554,40))). -user:metta_file_buffer(64,606002001,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1554,40),line_char(1554,41))). -user:metta_file_buffer(64,607002001,constant,')',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1554,41),line_char(1554,42))). -user:metta_file_buffer(65,608002002,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1556,1),line_char(1556,3))). -user:metta_file_buffer(65,608002002,constant,'noreduce-eq',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1556,4),line_char(1556,15))). -user:metta_file_buffer(65,608002002,constant,'PrivateRelation',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1556,16),line_char(1556,31))). -user:metta_file_buffer(64,608002002,metta_other,[iz,'noreduce-eq','PrivateRelation'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1556,0),line_char(1556,32))). -user:metta_file_buffer(65,609002003,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1557,1),line_char(1557,5))). -user:metta_file_buffer(65,609002003,constant,'noreduce-eq',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1557,6),line_char(1557,17))). -user:metta_file_buffer(66,609002004,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1558,3),line_char(1558,8))). -user:metta_file_buffer(66,609002004,string,"Checks equality of two atoms without reducing them",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1558,9),line_char(1558,61))). -user:metta_file_buffer(65,609002004,metta_other,['@desc',"Checks equality of two atoms without reducing them"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1558,2),line_char(1558,62))). -user:metta_file_buffer(66,609002005,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1559,3),line_char(1559,10))). -user:metta_file_buffer(68,609002007,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1560,5),line_char(1560,11))). -user:metta_file_buffer(68,609002007,string,"First atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1560,12),line_char(1560,24))). -user:metta_file_buffer(67,609002007,metta_other,['@param',"First atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1560,4),line_char(1560,25))). -user:metta_file_buffer(68,609002008,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1561,5),line_char(1561,11))). -user:metta_file_buffer(68,609002008,string,"Second atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1561,12),line_char(1561,25))). -user:metta_file_buffer(67,609002008,metta_other,['@param',"Second atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1561,4),line_char(1561,26))). -user:metta_file_buffer(66,609002008,array,[['@param',"First atom"],['@param',"Second atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1559,11),line_char(1561,27))). -user:metta_file_buffer(65,609002008,metta_other,['@params',[['@param',"First atom"],['@param',"Second atom"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1559,2),line_char(1561,28))). -user:metta_file_buffer(66,609002009,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1562,3),line_char(1562,10))). -user:metta_file_buffer(66,609002009,string,"True if not reduced atoms are equal, False - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1562,11),line_char(1562,67))). -user:metta_file_buffer(65,609002009,metta_other,['@return',"True if not reduced atoms are equal, False - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1562,2),line_char(1562,68))). -user:metta_file_buffer(64,609002009,metta_other,['@doc','noreduce-eq',['@desc',"Checks equality of two atoms without reducing them"],['@params',[['@param',"First atom"],['@param',"Second atom"]]],['@return',"True if not reduced atoms are equal, False - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1557,0),line_char(1562,69))). -user:metta_file_buffer(65,610002010,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1563,1),line_char(1563,2))). -user:metta_file_buffer(65,610002010,constant,'noreduce-eq',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1563,3),line_char(1563,14))). -user:metta_file_buffer(66,610002011,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1563,16),line_char(1563,18))). -user:metta_file_buffer(66,610002011,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1563,19),line_char(1563,23))). -user:metta_file_buffer(66,610002011,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1563,24),line_char(1563,28))). -user:metta_file_buffer(66,610002011,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1563,29),line_char(1563,33))). -user:metta_file_buffer(65,610002011,metta_other,[->,'Atom','Atom','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1563,15),line_char(1563,34))). -user:metta_file_buffer(64,610002011,metta_typedecl,[:,'noreduce-eq',[->,'Atom','Atom','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1563,0),line_char(1563,35))). -user:metta_file_buffer(65,611002012,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,1),line_char(1564,2))). -user:metta_file_buffer(66,611002013,constant,'noreduce-eq',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,4),line_char(1564,15))). -user:metta_file_buffer(66,611002013,variable,_559816,['_a'=_559816],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,16),line_char(1564,18))). -user:metta_file_buffer(66,611002013,variable,_561060,['_b'=_561060],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,19),line_char(1564,21))). -user:metta_file_buffer(65,611002013,indexed(metta_other,['noreduce-eq',_561900,_561922]),['noreduce-eq',_561974,_561980],['_b'=_561980,'_a'=_561974],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,3),line_char(1564,22))). -user:metta_file_buffer(66,611002014,constant,==,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,24),line_char(1564,26))). -user:metta_file_buffer(67,611002015,constant,quote,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,28),line_char(1564,33))). -user:metta_file_buffer(67,611002015,variable,_564502,['_a'=_564502],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,34),line_char(1564,36))). -user:metta_file_buffer(66,611002015,indexed(metta_other,[quote,_565336]),[quote,_565388],['_a'=_565388],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,27),line_char(1564,37))). -user:metta_file_buffer(67,611002016,constant,quote,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,39),line_char(1564,44))). -user:metta_file_buffer(67,611002016,variable,_567124,['_b'=_567124],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,45),line_char(1564,47))). -user:metta_file_buffer(66,611002016,indexed(metta_other,[quote,_567958]),[quote,_568010],['_b'=_568010],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,38),line_char(1564,48))). -user:metta_file_buffer(65,611002016,indexed(metta_other,[==,[quote,_568554],[quote,_568592]]),[==,[quote,_568656],[quote,_568674]],['_b'=_568674,'_a'=_568656],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,23),line_char(1564,49))). -user:metta_file_buffer(64,611002016,indexed(metta_defun,['noreduce-eq',_569230,_569252]),[=,['noreduce-eq',_569400,_569406],[==,[quote,_569400],[quote,_569406]]],['_b'=_569406,'_a'=_569400],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1564,0),line_char(1564,50))). -user:metta_file_buffer(64,612002016,indexed(metta_comment,";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"),'$COMMENT'(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",1566,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1566,0),line_char(1566,35))). -user:metta_file_buffer(64,612002016,indexed(metta_comment,"; Grounded function's documentation"),'$COMMENT'("; Grounded function's documentation",1567,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1567,0),line_char(1567,35))). -user:metta_file_buffer(64,612002016,indexed(metta_comment,";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"),'$COMMENT'(";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",1568,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1568,0),line_char(1568,35))). -user:metta_file_buffer(65,612002017,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1570,1),line_char(1570,3))). -user:metta_file_buffer(65,612002017,constant,'add-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1570,4),line_char(1570,12))). -user:metta_file_buffer(65,612002017,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1570,13),line_char(1570,18))). -user:metta_file_buffer(64,612002017,metta_other,[iz,'add-atom','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1570,0),line_char(1570,19))). -user:metta_file_buffer(65,613002018,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1571,1),line_char(1571,5))). -user:metta_file_buffer(65,613002018,constant,'add-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1571,6),line_char(1571,14))). -user:metta_file_buffer(66,613002019,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1572,3),line_char(1572,8))). -user:metta_file_buffer(66,613002019,string,"Adds atom into the atomspace without reducing it",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1572,9),line_char(1572,59))). -user:metta_file_buffer(65,613002019,metta_other,['@desc',"Adds atom into the atomspace without reducing it"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1572,2),line_char(1572,60))). -user:metta_file_buffer(66,613002020,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1573,3),line_char(1573,10))). -user:metta_file_buffer(68,613002022,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1574,5),line_char(1574,11))). -user:metta_file_buffer(68,613002022,string,"Atomspace to add atom into",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1574,12),line_char(1574,40))). -user:metta_file_buffer(67,613002022,metta_other,['@param',"Atomspace to add atom into"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1574,4),line_char(1574,41))). -user:metta_file_buffer(68,613002023,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1575,5),line_char(1575,11))). -user:metta_file_buffer(68,613002023,string,"Atom to add",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1575,12),line_char(1575,25))). -user:metta_file_buffer(67,613002023,metta_other,['@param',"Atom to add"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1575,4),line_char(1575,26))). -user:metta_file_buffer(66,613002023,array,[['@param',"Atomspace to add atom into"],['@param',"Atom to add"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1573,11),line_char(1575,27))). -user:metta_file_buffer(65,613002023,metta_other,['@params',[['@param',"Atomspace to add atom into"],['@param',"Atom to add"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1573,2),line_char(1575,28))). -user:metta_file_buffer(66,613002024,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1576,3),line_char(1576,10))). -user:metta_file_buffer(66,613002024,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1576,11),line_char(1576,22))). -user:metta_file_buffer(65,613002024,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1576,2),line_char(1576,23))). -user:metta_file_buffer(64,613002024,metta_other,['@doc','add-atom',['@desc',"Adds atom into the atomspace without reducing it"],['@params',[['@param',"Atomspace to add atom into"],['@param',"Atom to add"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1571,0),line_char(1576,24))). -user:metta_file_buffer(65,614002025,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1577,1),line_char(1577,2))). -user:metta_file_buffer(65,614002025,constant,'add-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1577,3),line_char(1577,11))). -user:metta_file_buffer(66,614002026,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1577,13),line_char(1577,15))). -user:metta_file_buffer(66,614002026,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1577,16),line_char(1577,40))). -user:metta_file_buffer(66,614002026,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1577,41),line_char(1577,45))). -user:metta_file_buffer(67,614002027,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1577,47),line_char(1577,49))). -user:metta_file_buffer(66,614002027,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1577,46),line_char(1577,50))). -user:metta_file_buffer(65,614002027,metta_other,[->,'hyperon::space::DynSpace','Atom',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1577,12),line_char(1577,51))). -user:metta_file_buffer(64,614002027,metta_typedecl,[:,'add-atom',[->,'hyperon::space::DynSpace','Atom',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1577,0),line_char(1577,52))). -user:metta_file_buffer(65,615002028,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1579,1),line_char(1579,3))). -user:metta_file_buffer(65,615002028,constant,'get-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1579,4),line_char(1579,12))). -user:metta_file_buffer(65,615002028,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1579,13),line_char(1579,18))). -user:metta_file_buffer(64,615002028,metta_other,[iz,'get-type','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1579,0),line_char(1579,19))). -user:metta_file_buffer(65,616002029,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1580,1),line_char(1580,5))). -user:metta_file_buffer(65,616002029,constant,'get-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1580,6),line_char(1580,14))). -user:metta_file_buffer(66,616002030,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1581,3),line_char(1581,8))). -user:metta_file_buffer(66,616002030,string,"Returns type notation of input atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1581,9),line_char(1581,46))). -user:metta_file_buffer(65,616002030,metta_other,['@desc',"Returns type notation of input atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1581,2),line_char(1581,47))). -user:metta_file_buffer(66,616002031,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1582,3),line_char(1582,10))). -user:metta_file_buffer(68,616002033,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1583,5),line_char(1583,11))). -user:metta_file_buffer(68,616002033,string,"Atom to get type for",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1583,12),line_char(1583,34))). -user:metta_file_buffer(67,616002033,metta_other,['@param',"Atom to get type for"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1583,4),line_char(1583,35))). -user:metta_file_buffer(66,616002033,array,[['@param',"Atom to get type for"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1582,11),line_char(1583,36))). -user:metta_file_buffer(65,616002033,metta_other,['@params',[['@param',"Atom to get type for"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1582,2),line_char(1583,37))). -user:metta_file_buffer(66,616002034,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1584,3),line_char(1584,10))). -user:metta_file_buffer(66,616002034,string,"Type notation or %Undefined% if there is no type for input Atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1584,11),line_char(1584,76))). -user:metta_file_buffer(65,616002034,metta_other,['@return',"Type notation or %Undefined% if there is no type for input Atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1584,2),line_char(1584,77))). -user:metta_file_buffer(64,616002034,metta_other,['@doc','get-type',['@desc',"Returns type notation of input atom"],['@params',[['@param',"Atom to get type for"]]],['@return',"Type notation or %Undefined% if there is no type for input Atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1580,0),line_char(1584,78))). -user:metta_file_buffer(65,617002035,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1585,1),line_char(1585,2))). -user:metta_file_buffer(65,617002035,constant,'get-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1585,3),line_char(1585,11))). -user:metta_file_buffer(66,617002036,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1585,13),line_char(1585,15))). -user:metta_file_buffer(66,617002036,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1585,16),line_char(1585,20))). -user:metta_file_buffer(66,617002036,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1585,21),line_char(1585,25))). -user:metta_file_buffer(65,617002036,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1585,12),line_char(1585,26))). -user:metta_file_buffer(64,617002036,metta_typedecl,[:,'get-type',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1585,0),line_char(1585,27))). -user:metta_file_buffer(65,618002037,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1586,1),line_char(1586,2))). -user:metta_file_buffer(65,618002037,constant,'get-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1586,3),line_char(1586,11))). -user:metta_file_buffer(66,618002038,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1586,13),line_char(1586,15))). -user:metta_file_buffer(66,618002038,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1586,16),line_char(1586,20))). -user:metta_file_buffer(66,618002038,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1586,21),line_char(1586,25))). -user:metta_file_buffer(66,618002038,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1586,26),line_char(1586,30))). -user:metta_file_buffer(65,618002038,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1586,12),line_char(1586,31))). -user:metta_file_buffer(64,618002038,metta_typedecl,[:,'get-type',[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1586,0),line_char(1586,32))). -user:metta_file_buffer(65,619002039,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1588,1),line_char(1588,3))). -user:metta_file_buffer(65,619002039,constant,'get-type-space',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1588,4),line_char(1588,18))). -user:metta_file_buffer(65,619002039,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1588,19),line_char(1588,24))). -user:metta_file_buffer(64,619002039,metta_other,[iz,'get-type-space','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1588,0),line_char(1588,25))). -user:metta_file_buffer(65,620002040,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1589,1),line_char(1589,5))). -user:metta_file_buffer(65,620002040,constant,'get-type-space',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1589,6),line_char(1589,20))). -user:metta_file_buffer(66,620002041,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1590,3),line_char(1590,8))). -user:metta_file_buffer(66,620002041,string,"Returns type notation of input Atom (second argument) relative to a specified atomspace (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1590,9),line_char(1590,115))). -user:metta_file_buffer(65,620002041,metta_other,['@desc',"Returns type notation of input Atom (second argument) relative to a specified atomspace (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1590,2),line_char(1590,116))). -user:metta_file_buffer(66,620002042,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1591,3),line_char(1591,10))). -user:metta_file_buffer(68,620002044,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1592,5),line_char(1592,11))). -user:metta_file_buffer(68,620002044,string,"Atomspace where type notation for input atom will be searched",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1592,12),line_char(1592,75))). -user:metta_file_buffer(67,620002044,metta_other,['@param',"Atomspace where type notation for input atom will be searched"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1592,4),line_char(1592,76))). -user:metta_file_buffer(68,620002045,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1593,5),line_char(1593,11))). -user:metta_file_buffer(68,620002045,string,"Atom to get type for",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1593,12),line_char(1593,34))). -user:metta_file_buffer(67,620002045,metta_other,['@param',"Atom to get type for"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1593,4),line_char(1593,35))). -user:metta_file_buffer(66,620002045,array,[['@param',"Atomspace where type notation for input atom will be searched"],['@param',"Atom to get type for"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1591,11),line_char(1593,36))). -user:metta_file_buffer(65,620002045,metta_other,['@params',[['@param',"Atomspace where type notation for input atom will be searched"],['@param',"Atom to get type for"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1591,2),line_char(1593,37))). -user:metta_file_buffer(66,620002046,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1594,3),line_char(1594,10))). -user:metta_file_buffer(66,620002046,string,"Type notation or %Undefined% if there is no type for input Atom in provided atomspace",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1594,11),line_char(1594,98))). -user:metta_file_buffer(65,620002046,metta_other,['@return',"Type notation or %Undefined% if there is no type for input Atom in provided atomspace"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1594,2),line_char(1594,99))). -user:metta_file_buffer(64,620002046,metta_other,['@doc','get-type-space',['@desc',"Returns type notation of input Atom (second argument) relative to a specified atomspace (first argument)"],['@params',[['@param',"Atomspace where type notation for input atom will be searched"],['@param',"Atom to get type for"]]],['@return',"Type notation or %Undefined% if there is no type for input Atom in provided atomspace"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1589,0),line_char(1594,100))). -user:metta_file_buffer(65,621002047,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1595,1),line_char(1595,3))). -user:metta_file_buffer(65,621002047,constant,'get-type-space',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1595,4),line_char(1595,18))). -user:metta_file_buffer(65,621002047,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1595,19),line_char(1595,24))). -user:metta_file_buffer(64,621002047,metta_other,[iz,'get-type-space','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1595,0),line_char(1595,25))). -user:metta_file_buffer(65,622002048,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1596,1),line_char(1596,2))). -user:metta_file_buffer(65,622002048,constant,'get-type-space',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1596,3),line_char(1596,17))). -user:metta_file_buffer(66,622002049,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1596,19),line_char(1596,21))). -user:metta_file_buffer(66,622002049,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1596,22),line_char(1596,26))). -user:metta_file_buffer(66,622002049,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1596,27),line_char(1596,31))). -user:metta_file_buffer(66,622002049,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1596,32),line_char(1596,36))). -user:metta_file_buffer(65,622002049,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1596,18),line_char(1596,37))). -user:metta_file_buffer(64,622002049,metta_typedecl,[:,'get-type-space',[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1596,0),line_char(1596,38))). -user:metta_file_buffer(65,623002050,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1597,1),line_char(1597,2))). -user:metta_file_buffer(66,623002051,constant,'get-type-space',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1597,4),line_char(1597,18))). -user:metta_file_buffer(66,623002051,variable,_562626,['_space'=_562626],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1597,19),line_char(1597,25))). -user:metta_file_buffer(66,623002051,variable,_563918,['_atom'=_563918],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1597,26),line_char(1597,31))). -user:metta_file_buffer(65,623002051,indexed(metta_other,['get-type-space',_564758,_564780]),['get-type-space',_564832,_564838],['_atom'=_564838,'_space'=_564832],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1597,3),line_char(1597,32))). -user:metta_file_buffer(66,623002052,constant,'get-type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1598,9),line_char(1598,17))). -user:metta_file_buffer(66,623002052,variable,_566590,['_atom'=_566590],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1598,18),line_char(1598,23))). -user:metta_file_buffer(66,623002052,variable,_567898,['_space'=_567898],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1598,24),line_char(1598,30))). -user:metta_file_buffer(65,623002052,indexed(metta_other,['get-type',_568738,_568760]),['get-type',_568812,_568818],['_space'=_568818,'_atom'=_568812],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1598,8),line_char(1598,31))). -user:metta_file_buffer(64,623002052,indexed(metta_defun,['get-type-space',_569374,_569396]),[=,['get-type-space',_569512,_569518],['get-type',_569518,_569512]],['_atom'=_569518,'_space'=_569512],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1597,0),line_char(1598,32))). -user:metta_file_buffer(65,624002053,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1600,1),line_char(1600,3))). -user:metta_file_buffer(65,624002053,constant,'get-metatype',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1600,4),line_char(1600,16))). -user:metta_file_buffer(65,624002053,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1600,17),line_char(1600,22))). -user:metta_file_buffer(64,624002053,metta_other,[iz,'get-metatype','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1600,0),line_char(1600,23))). -user:metta_file_buffer(65,625002054,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1601,1),line_char(1601,5))). -user:metta_file_buffer(65,625002054,constant,'get-metatype',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1601,6),line_char(1601,18))). -user:metta_file_buffer(66,625002055,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1602,3),line_char(1602,8))). -user:metta_file_buffer(66,625002055,string,"Returns metatype of the input atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1602,9),line_char(1602,45))). -user:metta_file_buffer(65,625002055,metta_other,['@desc',"Returns metatype of the input atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1602,2),line_char(1602,46))). -user:metta_file_buffer(66,625002056,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1603,3),line_char(1603,10))). -user:metta_file_buffer(68,625002058,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1604,5),line_char(1604,11))). -user:metta_file_buffer(68,625002058,string,"Atom to get metatype for",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1604,12),line_char(1604,38))). -user:metta_file_buffer(67,625002058,metta_other,['@param',"Atom to get metatype for"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1604,4),line_char(1604,39))). -user:metta_file_buffer(66,625002058,array,[['@param',"Atom to get metatype for"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1603,11),line_char(1604,40))). -user:metta_file_buffer(65,625002058,metta_other,['@params',[['@param',"Atom to get metatype for"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1603,2),line_char(1604,41))). -user:metta_file_buffer(66,625002059,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1605,3),line_char(1605,10))). -user:metta_file_buffer(66,625002059,string,"Metatype of input atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1605,11),line_char(1605,35))). -user:metta_file_buffer(65,625002059,metta_other,['@return',"Metatype of input atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1605,2),line_char(1605,36))). -user:metta_file_buffer(64,625002059,metta_other,['@doc','get-metatype',['@desc',"Returns metatype of the input atom"],['@params',[['@param',"Atom to get metatype for"]]],['@return',"Metatype of input atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1601,0),line_char(1605,37))). -user:metta_file_buffer(65,626002060,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1606,1),line_char(1606,2))). -user:metta_file_buffer(65,626002060,constant,'get-metatype',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1606,3),line_char(1606,15))). -user:metta_file_buffer(66,626002061,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1606,17),line_char(1606,19))). -user:metta_file_buffer(66,626002061,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1606,20),line_char(1606,24))). -user:metta_file_buffer(66,626002061,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1606,25),line_char(1606,29))). -user:metta_file_buffer(65,626002061,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1606,16),line_char(1606,30))). -user:metta_file_buffer(64,626002061,metta_typedecl,[:,'get-metatype',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1606,0),line_char(1606,31))). -user:metta_file_buffer(65,627002062,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1609,1),line_char(1609,3))). -user:metta_file_buffer(65,627002062,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1609,4),line_char(1609,12))). -user:metta_file_buffer(65,627002062,constant,'MinimalMeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1609,13),line_char(1609,25))). -user:metta_file_buffer(64,627002062,metta_other,[iz,'if-equal','MinimalMeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1609,0),line_char(1609,26))). -user:metta_file_buffer(65,628002063,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1610,1),line_char(1610,5))). -user:metta_file_buffer(65,628002063,constant,'if-equal',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1610,6),line_char(1610,14))). -user:metta_file_buffer(66,628002064,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1611,3),line_char(1611,8))). -user:metta_file_buffer(66,628002064,string,"Checks if first two arguments are equal and evaluates third argument if equal, fourth argument - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1611,9),line_char(1611,117))). -user:metta_file_buffer(65,628002064,metta_other,['@desc',"Checks if first two arguments are equal and evaluates third argument if equal, fourth argument - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1611,2),line_char(1611,118))). -user:metta_file_buffer(66,628002065,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1612,3),line_char(1612,10))). -user:metta_file_buffer(68,628002067,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1613,5),line_char(1613,11))). -user:metta_file_buffer(68,628002067,string,"First argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1613,12),line_char(1613,28))). -user:metta_file_buffer(67,628002067,metta_other,['@param',"First argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1613,4),line_char(1613,29))). -user:metta_file_buffer(68,628002068,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1614,5),line_char(1614,11))). -user:metta_file_buffer(68,628002068,string,"Second argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1614,12),line_char(1614,29))). -user:metta_file_buffer(67,628002068,metta_other,['@param',"Second argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1614,4),line_char(1614,30))). -user:metta_file_buffer(68,628002069,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1615,5),line_char(1615,11))). -user:metta_file_buffer(68,628002069,string,"Atom to be evaluated if arguments are equal",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1615,12),line_char(1615,57))). -user:metta_file_buffer(67,628002069,metta_other,['@param',"Atom to be evaluated if arguments are equal"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1615,4),line_char(1615,58))). -user:metta_file_buffer(68,628002070,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1616,5),line_char(1616,11))). -user:metta_file_buffer(68,628002070,string,"Atom to be evaluated if arguments are not equal",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1616,12),line_char(1616,61))). -user:metta_file_buffer(67,628002070,metta_other,['@param',"Atom to be evaluated if arguments are not equal"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1616,4),line_char(1616,62))). -user:metta_file_buffer(66,628002070,array,[['@param',"First argument"],['@param',"Second argument"],['@param',"Atom to be evaluated if arguments are equal"],['@param',"Atom to be evaluated if arguments are not equal"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1612,11),line_char(1616,63))). -user:metta_file_buffer(65,628002070,metta_other,['@params',[['@param',"First argument"],['@param',"Second argument"],['@param',"Atom to be evaluated if arguments are equal"],['@param',"Atom to be evaluated if arguments are not equal"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1612,2),line_char(1616,64))). -user:metta_file_buffer(66,628002071,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1617,3),line_char(1617,10))). -user:metta_file_buffer(66,628002071,string,"Evaluated third or fourth argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1617,11),line_char(1617,47))). -user:metta_file_buffer(65,628002071,metta_other,['@return',"Evaluated third or fourth argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1617,2),line_char(1617,48))). -user:metta_file_buffer(64,628002071,metta_other,['@doc','if-equal',['@desc',"Checks if first two arguments are equal and evaluates third argument if equal, fourth argument - otherwise"],['@params',[['@param',"First argument"],['@param',"Second argument"],['@param',"Atom to be evaluated if arguments are equal"],['@param',"Atom to be evaluated if arguments are not equal"]]],['@return',"Evaluated third or fourth argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1610,0),line_char(1617,49))). -user:metta_file_buffer(65,629002072,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1620,1),line_char(1620,3))). -user:metta_file_buffer(65,629002072,constant,'new-space',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1620,4),line_char(1620,13))). -user:metta_file_buffer(65,629002072,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1620,14),line_char(1620,19))). -user:metta_file_buffer(64,629002072,metta_other,[iz,'new-space','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1620,0),line_char(1620,20))). -user:metta_file_buffer(65,630002073,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1621,1),line_char(1621,5))). -user:metta_file_buffer(65,630002073,constant,'new-space',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1621,6),line_char(1621,15))). -user:metta_file_buffer(66,630002074,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1622,3),line_char(1622,8))). -user:metta_file_buffer(66,630002074,string,"Creates new Atomspace which could be used further in the program as a separate from &self Atomspace",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1622,9),line_char(1622,110))). -user:metta_file_buffer(65,630002074,metta_other,['@desc',"Creates new Atomspace which could be used further in the program as a separate from &self Atomspace"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1622,2),line_char(1622,111))). -user:metta_file_buffer(66,630002075,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1623,3),line_char(1623,10))). -user:metta_file_buffer(66,630002076,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1623,11),line_char(1623,13))). -user:metta_file_buffer(65,630002076,metta_other,['@params',[]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1623,2),line_char(1623,14))). -user:metta_file_buffer(66,630002077,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1624,3),line_char(1624,10))). -user:metta_file_buffer(66,630002077,string,"Reference to a new space",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1624,11),line_char(1624,37))). -user:metta_file_buffer(65,630002077,metta_other,['@return',"Reference to a new space"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1624,2),line_char(1624,38))). -user:metta_file_buffer(64,630002077,metta_other,['@doc','new-space',['@desc',"Creates new Atomspace which could be used further in the program as a separate from &self Atomspace"],['@params',[]],['@return',"Reference to a new space"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1621,0),line_char(1624,39))). -user:metta_file_buffer(65,631002078,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1625,1),line_char(1625,2))). -user:metta_file_buffer(65,631002078,constant,'new-space',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1625,3),line_char(1625,12))). -user:metta_file_buffer(66,631002079,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1625,14),line_char(1625,16))). -user:metta_file_buffer(66,631002079,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1625,17),line_char(1625,41))). -user:metta_file_buffer(65,631002079,metta_other,[->,'hyperon::space::DynSpace'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1625,13),line_char(1625,42))). -user:metta_file_buffer(64,631002079,metta_typedecl,[:,'new-space',[->,'hyperon::space::DynSpace']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1625,0),line_char(1625,43))). -user:metta_file_buffer(65,632002080,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1628,1),line_char(1628,3))). -user:metta_file_buffer(65,632002080,constant,'remove-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1628,4),line_char(1628,15))). -user:metta_file_buffer(65,632002080,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1628,16),line_char(1628,21))). -user:metta_file_buffer(64,632002080,metta_other,[iz,'remove-atom','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1628,0),line_char(1628,22))). -user:metta_file_buffer(65,633002081,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1629,1),line_char(1629,5))). -user:metta_file_buffer(65,633002081,constant,'remove-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1629,6),line_char(1629,17))). -user:metta_file_buffer(66,633002082,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1630,3),line_char(1630,8))). -user:metta_file_buffer(66,633002082,string,"Removes atom from the input Atomspace",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1630,9),line_char(1630,48))). -user:metta_file_buffer(65,633002082,metta_other,['@desc',"Removes atom from the input Atomspace"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1630,2),line_char(1630,49))). -user:metta_file_buffer(66,633002083,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1631,3),line_char(1631,10))). -user:metta_file_buffer(68,633002085,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1632,5),line_char(1632,11))). -user:metta_file_buffer(68,633002085,string,"Reference to the space from which the Atom needs to be removed",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1632,12),line_char(1632,76))). -user:metta_file_buffer(67,633002085,metta_other,['@param',"Reference to the space from which the Atom needs to be removed"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1632,4),line_char(1632,77))). -user:metta_file_buffer(68,633002086,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1633,5),line_char(1633,11))). -user:metta_file_buffer(68,633002086,string,"Atom to be removed",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1633,12),line_char(1633,32))). -user:metta_file_buffer(67,633002086,metta_other,['@param',"Atom to be removed"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1633,4),line_char(1633,33))). -user:metta_file_buffer(66,633002086,array,[['@param',"Reference to the space from which the Atom needs to be removed"],['@param',"Atom to be removed"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1631,11),line_char(1633,34))). -user:metta_file_buffer(65,633002086,metta_other,['@params',[['@param',"Reference to the space from which the Atom needs to be removed"],['@param',"Atom to be removed"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1631,2),line_char(1633,35))). -user:metta_file_buffer(66,633002087,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1634,3),line_char(1634,10))). -user:metta_file_buffer(66,633002087,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1634,11),line_char(1634,22))). -user:metta_file_buffer(65,633002087,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1634,2),line_char(1634,23))). -user:metta_file_buffer(64,633002087,metta_other,['@doc','remove-atom',['@desc',"Removes atom from the input Atomspace"],['@params',[['@param',"Reference to the space from which the Atom needs to be removed"],['@param',"Atom to be removed"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1629,0),line_char(1634,24))). -user:metta_file_buffer(65,634002088,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1635,1),line_char(1635,2))). -user:metta_file_buffer(65,634002088,constant,'remove-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1635,3),line_char(1635,14))). -user:metta_file_buffer(66,634002089,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1635,16),line_char(1635,18))). -user:metta_file_buffer(66,634002089,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1635,19),line_char(1635,43))). -user:metta_file_buffer(66,634002089,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1635,44),line_char(1635,48))). -user:metta_file_buffer(67,634002090,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1635,50),line_char(1635,52))). -user:metta_file_buffer(66,634002090,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1635,49),line_char(1635,53))). -user:metta_file_buffer(65,634002090,metta_other,[->,'hyperon::space::DynSpace','Atom',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1635,15),line_char(1635,54))). -user:metta_file_buffer(64,634002090,metta_typedecl,[:,'remove-atom',[->,'hyperon::space::DynSpace','Atom',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1635,0),line_char(1635,55))). -user:metta_file_buffer(65,635002091,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1638,1),line_char(1638,3))). -user:metta_file_buffer(65,635002091,constant,'get-atoms',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1638,4),line_char(1638,13))). -user:metta_file_buffer(65,635002091,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1638,14),line_char(1638,19))). -user:metta_file_buffer(64,635002091,metta_other,[iz,'get-atoms','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1638,0),line_char(1638,20))). -user:metta_file_buffer(65,636002092,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1639,1),line_char(1639,5))). -user:metta_file_buffer(65,636002092,constant,'get-atoms',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1639,6),line_char(1639,15))). -user:metta_file_buffer(66,636002093,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1640,3),line_char(1640,8))). -user:metta_file_buffer(66,636002093,string,"Shows all atoms in the input Atomspace",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1640,9),line_char(1640,49))). -user:metta_file_buffer(65,636002093,metta_other,['@desc',"Shows all atoms in the input Atomspace"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1640,2),line_char(1640,50))). -user:metta_file_buffer(66,636002094,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1641,3),line_char(1641,10))). -user:metta_file_buffer(68,636002096,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1642,5),line_char(1642,11))). -user:metta_file_buffer(68,636002096,string,"Reference to the space",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1642,12),line_char(1642,36))). -user:metta_file_buffer(67,636002096,metta_other,['@param',"Reference to the space"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1642,4),line_char(1642,37))). -user:metta_file_buffer(66,636002096,array,[['@param',"Reference to the space"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1641,11),line_char(1642,38))). -user:metta_file_buffer(65,636002096,metta_other,['@params',[['@param',"Reference to the space"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1641,2),line_char(1642,39))). -user:metta_file_buffer(66,636002097,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1643,3),line_char(1643,10))). -user:metta_file_buffer(66,636002097,string,"List of all atoms in the input space",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1643,11),line_char(1643,49))). -user:metta_file_buffer(65,636002097,metta_other,['@return',"List of all atoms in the input space"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1643,2),line_char(1643,50))). -user:metta_file_buffer(64,636002097,metta_other,['@doc','get-atoms',['@desc',"Shows all atoms in the input Atomspace"],['@params',[['@param',"Reference to the space"]]],['@return',"List of all atoms in the input space"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1639,0),line_char(1643,51))). -user:metta_file_buffer(65,637002098,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1645,1),line_char(1645,2))). -user:metta_file_buffer(65,637002098,constant,'get-atoms',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1645,3),line_char(1645,12))). -user:metta_file_buffer(66,637002099,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1645,14),line_char(1645,16))). -user:metta_file_buffer(66,637002099,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1645,17),line_char(1645,41))). -user:metta_file_buffer(66,637002099,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1645,42),line_char(1645,46))). -user:metta_file_buffer(65,637002099,metta_other,[->,'hyperon::space::DynSpace','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1645,13),line_char(1645,47))). -user:metta_file_buffer(64,637002099,metta_typedecl,[:,'get-atoms',[->,'hyperon::space::DynSpace','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1645,0),line_char(1645,48))). -user:metta_file_buffer(65,638002100,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1649,1),line_char(1649,3))). -user:metta_file_buffer(65,638002100,constant,'new-state',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1649,4),line_char(1649,13))). -user:metta_file_buffer(65,638002100,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1649,14),line_char(1649,19))). -user:metta_file_buffer(64,638002100,metta_other,[iz,'new-state','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1649,0),line_char(1649,20))). -user:metta_file_buffer(65,639002101,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1650,1),line_char(1650,5))). -user:metta_file_buffer(65,639002101,constant,'new-state',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1650,6),line_char(1650,15))). -user:metta_file_buffer(66,639002102,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1651,3),line_char(1651,8))). -user:metta_file_buffer(66,639002102,string,"Creates a new state atom wrapping its argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1651,9),line_char(1651,57))). -user:metta_file_buffer(65,639002102,metta_other,['@desc',"Creates a new state atom wrapping its argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1651,2),line_char(1651,58))). -user:metta_file_buffer(66,639002103,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1652,3),line_char(1652,10))). -user:metta_file_buffer(68,639002105,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1653,5),line_char(1653,11))). -user:metta_file_buffer(68,639002105,string,"Atom to be wrapped",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1653,12),line_char(1653,32))). -user:metta_file_buffer(67,639002105,metta_other,['@param',"Atom to be wrapped"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1653,4),line_char(1653,33))). -user:metta_file_buffer(66,639002105,array,[['@param',"Atom to be wrapped"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1652,11),line_char(1653,34))). -user:metta_file_buffer(65,639002105,metta_other,['@params',[['@param',"Atom to be wrapped"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1652,2),line_char(1653,35))). -user:metta_file_buffer(66,639002106,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1654,3),line_char(1654,10))). -user:metta_file_buffer(66,639002106,string,"Returns (State $value) where $value is an argument to a new-state",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1654,11),line_char(1654,78))). -user:metta_file_buffer(65,639002106,metta_other,['@return',"Returns (State $value) where $value is an argument to a new-state"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1654,2),line_char(1654,79))). -user:metta_file_buffer(64,639002106,metta_other,['@doc','new-state',['@desc',"Creates a new state atom wrapping its argument"],['@params',[['@param',"Atom to be wrapped"]]],['@return',"Returns (State $value) where $value is an argument to a new-state"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1650,0),line_char(1654,80))). -user:metta_file_buffer(65,640002107,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1655,1),line_char(1655,2))). -user:metta_file_buffer(65,640002107,constant,'new-state',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1655,3),line_char(1655,12))). -user:metta_file_buffer(66,640002108,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1655,14),line_char(1655,16))). -user:metta_file_buffer(66,640002108,variable,_571404,['_tnso'=_571404],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1655,17),line_char(1655,22))). -user:metta_file_buffer(67,640002109,constant,'StateMonad',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1655,24),line_char(1655,34))). -user:metta_file_buffer(67,640002109,variable,_573482,['_tnso'=_573482],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1655,35),line_char(1655,40))). -user:metta_file_buffer(66,640002109,indexed(metta_other,['StateMonad',_574316]),['StateMonad',_574368],['_tnso'=_574368],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1655,23),line_char(1655,41))). -user:metta_file_buffer(65,640002109,indexed(metta_other,[->,_574896,['StateMonad',_574896]]),[->,_574982,['StateMonad',_574982]],['_tnso'=_574982],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1655,13),line_char(1655,42))). -user:metta_file_buffer(64,640002109,indexed(metta_typedecl,[:,'new-state',[->,_575552,['StateMonad',_575552]]]),[:,'new-state',[->,_575656,['StateMonad',_575656]]],['_tnso'=_575656],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1655,0),line_char(1655,43))). -user:metta_file_buffer(65,641002110,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1658,1),line_char(1658,3))). -user:metta_file_buffer(65,641002110,constant,'change-state!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1658,4),line_char(1658,17))). -user:metta_file_buffer(65,641002110,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1658,18),line_char(1658,23))). -user:metta_file_buffer(64,641002110,metta_other,[iz,'change-state!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1658,0),line_char(1658,24))). -user:metta_file_buffer(65,642002111,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1659,1),line_char(1659,5))). -user:metta_file_buffer(65,642002111,constant,'change-state!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1659,6),line_char(1659,19))). -user:metta_file_buffer(66,642002112,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1660,3),line_char(1660,8))). -user:metta_file_buffer(66,642002112,string,"Changes input state's wrapped atom to another value (second argument). E.g. (change-state! (State 5) 6) -> (State 6)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1660,9),line_char(1660,127))). -user:metta_file_buffer(65,642002112,metta_other,['@desc',"Changes input state's wrapped atom to another value (second argument). E.g. (change-state! (State 5) 6) -> (State 6)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1660,2),line_char(1660,128))). -user:metta_file_buffer(66,642002113,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1661,3),line_char(1661,10))). -user:metta_file_buffer(68,642002115,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1662,5),line_char(1662,11))). -user:metta_file_buffer(68,642002115,string,"State created by new-state function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1662,12),line_char(1662,49))). -user:metta_file_buffer(67,642002115,metta_other,['@param',"State created by new-state function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1662,4),line_char(1662,50))). -user:metta_file_buffer(68,642002116,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1663,5),line_char(1663,11))). -user:metta_file_buffer(68,642002116,string,"Atom which will replace wrapped atom in the input state",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1663,12),line_char(1663,69))). -user:metta_file_buffer(67,642002116,metta_other,['@param',"Atom which will replace wrapped atom in the input state"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1663,4),line_char(1663,70))). -user:metta_file_buffer(66,642002116,array,[['@param',"State created by new-state function"],['@param',"Atom which will replace wrapped atom in the input state"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1661,11),line_char(1663,71))). -user:metta_file_buffer(65,642002116,metta_other,['@params',[['@param',"State created by new-state function"],['@param',"Atom which will replace wrapped atom in the input state"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1661,2),line_char(1663,72))). -user:metta_file_buffer(66,642002117,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1664,3),line_char(1664,10))). -user:metta_file_buffer(66,642002117,string,"State with replaced wrapped atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1664,11),line_char(1664,45))). -user:metta_file_buffer(65,642002117,metta_other,['@return',"State with replaced wrapped atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1664,2),line_char(1664,46))). -user:metta_file_buffer(64,642002117,metta_other,['@doc','change-state!',['@desc',"Changes input state's wrapped atom to another value (second argument). E.g. (change-state! (State 5) 6) -> (State 6)"],['@params',[['@param',"State created by new-state function"],['@param',"Atom which will replace wrapped atom in the input state"]]],['@return',"State with replaced wrapped atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1659,0),line_char(1664,47))). -user:metta_file_buffer(65,643002118,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1665,1),line_char(1665,2))). -user:metta_file_buffer(65,643002118,constant,'change-state!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1665,3),line_char(1665,16))). -user:metta_file_buffer(66,643002119,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1665,18),line_char(1665,20))). -user:metta_file_buffer(67,643002120,constant,'StateMonad',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1665,22),line_char(1665,32))). -user:metta_file_buffer(67,643002120,variable,_574730,['_tcso'=_574730],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1665,33),line_char(1665,38))). -user:metta_file_buffer(66,643002120,indexed(metta_other,['StateMonad',_575564]),['StateMonad',_575616],['_tcso'=_575616],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1665,21),line_char(1665,39))). -user:metta_file_buffer(66,643002120,variable,_576588,['_tcso'=_576588],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1665,40),line_char(1665,45))). -user:metta_file_buffer(67,643002121,constant,'StateMonad',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1665,47),line_char(1665,57))). -user:metta_file_buffer(67,643002121,variable,_578666,['_tcso'=_578666],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1665,58),line_char(1665,63))). -user:metta_file_buffer(66,643002121,indexed(metta_other,['StateMonad',_579500]),['StateMonad',_579552],['_tcso'=_579552],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1665,46),line_char(1665,64))). -user:metta_file_buffer(65,643002121,indexed(metta_other,[->,['StateMonad',_580102],_580102,['StateMonad',_580102]]),[->,['StateMonad',_580218],_580218,['StateMonad',_580218]],['_tcso'=_580218],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1665,17),line_char(1665,65))). -user:metta_file_buffer(64,643002121,indexed(metta_typedecl,[:,'change-state!',[->,['StateMonad',_580810],_580810,['StateMonad',_580810]]]),[:,'change-state!',[->,['StateMonad',_580944],_580944,['StateMonad',_580944]]],['_tcso'=_580944],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1665,0),line_char(1665,66))). -user:metta_file_buffer(65,644002122,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1668,1),line_char(1668,3))). -user:metta_file_buffer(65,644002122,constant,'get-state',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1668,4),line_char(1668,13))). -user:metta_file_buffer(65,644002122,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1668,14),line_char(1668,19))). -user:metta_file_buffer(64,644002122,metta_other,[iz,'get-state','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1668,0),line_char(1668,20))). -user:metta_file_buffer(65,645002123,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1669,1),line_char(1669,5))). -user:metta_file_buffer(65,645002123,constant,'get-state',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1669,6),line_char(1669,15))). -user:metta_file_buffer(66,645002124,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1670,3),line_char(1670,8))). -user:metta_file_buffer(66,645002124,string,"Gets a state as an argument and returns its wrapped atom. E.g. (get-state (State 5)) -> 5",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1670,9),line_char(1670,100))). -user:metta_file_buffer(65,645002124,metta_other,['@desc',"Gets a state as an argument and returns its wrapped atom. E.g. (get-state (State 5)) -> 5"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1670,2),line_char(1670,101))). -user:metta_file_buffer(66,645002125,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1671,3),line_char(1671,10))). -user:metta_file_buffer(68,645002127,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1672,5),line_char(1672,11))). -user:metta_file_buffer(68,645002127,string,"State",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1672,12),line_char(1672,19))). -user:metta_file_buffer(67,645002127,metta_other,['@param',"State"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1672,4),line_char(1672,20))). -user:metta_file_buffer(66,645002127,array,[['@param',"State"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1671,11),line_char(1672,21))). -user:metta_file_buffer(65,645002127,metta_other,['@params',[['@param',"State"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1671,2),line_char(1672,22))). -user:metta_file_buffer(66,645002128,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1673,3),line_char(1673,10))). -user:metta_file_buffer(66,645002128,string,"Atom wrapped by state",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1673,11),line_char(1673,34))). -user:metta_file_buffer(65,645002128,metta_other,['@return',"Atom wrapped by state"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1673,2),line_char(1673,35))). -user:metta_file_buffer(64,645002128,metta_other,['@doc','get-state',['@desc',"Gets a state as an argument and returns its wrapped atom. E.g. (get-state (State 5)) -> 5"],['@params',[['@param',"State"]]],['@return',"Atom wrapped by state"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1669,0),line_char(1673,36))). -user:metta_file_buffer(65,646002129,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1674,1),line_char(1674,2))). -user:metta_file_buffer(65,646002129,constant,'get-state',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1674,3),line_char(1674,12))). -user:metta_file_buffer(66,646002130,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1674,14),line_char(1674,16))). -user:metta_file_buffer(67,646002131,constant,'StateMonad',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1674,18),line_char(1674,28))). -user:metta_file_buffer(67,646002131,variable,_575780,['_tgso'=_575780],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1674,29),line_char(1674,34))). -user:metta_file_buffer(66,646002131,indexed(metta_other,['StateMonad',_576614]),['StateMonad',_576666],['_tgso'=_576666],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1674,17),line_char(1674,35))). -user:metta_file_buffer(66,646002131,variable,_577646,['_tgso'=_577646],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1674,36),line_char(1674,41))). -user:metta_file_buffer(65,646002131,indexed(metta_other,[->,['StateMonad',_578502],_578502]),[->,['StateMonad',_578584],_578584],['_tgso'=_578584],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1674,13),line_char(1674,42))). -user:metta_file_buffer(64,646002131,indexed(metta_typedecl,[:,'get-state',[->,['StateMonad',_579158],_579158]]),[:,'get-state',[->,['StateMonad',_579258],_579258]],['_tgso'=_579258],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1674,0),line_char(1674,43))). -user:metta_file_buffer(65,647002132,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1678,1),line_char(1678,3))). -user:metta_file_buffer(65,647002132,constant,match,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1678,4),line_char(1678,9))). -user:metta_file_buffer(65,647002132,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1678,10),line_char(1678,15))). -user:metta_file_buffer(64,647002132,metta_other,[iz,match,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1678,0),line_char(1678,16))). -user:metta_file_buffer(65,648002133,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1679,1),line_char(1679,5))). -user:metta_file_buffer(65,648002133,constant,match,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1679,6),line_char(1679,11))). -user:metta_file_buffer(66,648002134,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1680,3),line_char(1680,8))). -user:metta_file_buffer(66,648002134,string,"Searches for all declared atoms corresponding to the given pattern (second argument) and produces the output pattern (third argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1680,9),line_char(1680,144))). -user:metta_file_buffer(65,648002134,metta_other,['@desc',"Searches for all declared atoms corresponding to the given pattern (second argument) and produces the output pattern (third argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1680,2),line_char(1680,145))). -user:metta_file_buffer(66,648002135,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1681,3),line_char(1681,10))). -user:metta_file_buffer(68,648002137,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1682,5),line_char(1682,11))). -user:metta_file_buffer(68,648002137,string,"A grounded atom referencing a Space",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1682,12),line_char(1682,49))). -user:metta_file_buffer(67,648002137,metta_other,['@param',"A grounded atom referencing a Space"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1682,4),line_char(1682,50))). -user:metta_file_buffer(68,648002138,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1683,5),line_char(1683,11))). -user:metta_file_buffer(68,648002138,string,"Pattern atom to be searched",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1683,12),line_char(1683,41))). -user:metta_file_buffer(67,648002138,metta_other,['@param',"Pattern atom to be searched"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1683,4),line_char(1683,42))). -user:metta_file_buffer(68,648002139,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1684,5),line_char(1684,11))). -user:metta_file_buffer(68,648002139,string,"Output template typically containing variables from the input pattern",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1684,12),line_char(1684,83))). -user:metta_file_buffer(67,648002139,metta_other,['@param',"Output template typically containing variables from the input pattern"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1684,4),line_char(1684,84))). -user:metta_file_buffer(66,648002139,array,[['@param',"A grounded atom referencing a Space"],['@param',"Pattern atom to be searched"],['@param',"Output template typically containing variables from the input pattern"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1681,11),line_char(1684,85))). -user:metta_file_buffer(65,648002139,metta_other,['@params',[['@param',"A grounded atom referencing a Space"],['@param',"Pattern atom to be searched"],['@param',"Output template typically containing variables from the input pattern"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1681,2),line_char(1684,86))). -user:metta_file_buffer(66,648002140,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1685,3),line_char(1685,10))). -user:metta_file_buffer(66,648002140,string,"If match was successful it outputs template (third argument) with filled variables (if any were present in pattern) using matched pattern (second argument). Empty - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1685,11),line_char(1685,187))). -user:metta_file_buffer(65,648002140,metta_other,['@return',"If match was successful it outputs template (third argument) with filled variables (if any were present in pattern) using matched pattern (second argument). Empty - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1685,2),line_char(1685,188))). -user:metta_file_buffer(64,648002140,metta_other,['@doc',match,['@desc',"Searches for all declared atoms corresponding to the given pattern (second argument) and produces the output pattern (third argument)"],['@params',[['@param',"A grounded atom referencing a Space"],['@param',"Pattern atom to be searched"],['@param',"Output template typically containing variables from the input pattern"]]],['@return',"If match was successful it outputs template (third argument) with filled variables (if any were present in pattern) using matched pattern (second argument). Empty - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1679,0),line_char(1685,189))). -user:metta_file_buffer(65,649002141,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1687,1),line_char(1687,2))). -user:metta_file_buffer(65,649002141,constant,match,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1687,3),line_char(1687,8))). -user:metta_file_buffer(66,649002142,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1687,10),line_char(1687,12))). -user:metta_file_buffer(66,649002142,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1687,13),line_char(1687,17))). -user:metta_file_buffer(66,649002142,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1687,18),line_char(1687,22))). -user:metta_file_buffer(66,649002142,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1687,23),line_char(1687,27))). -user:metta_file_buffer(66,649002142,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1687,28),line_char(1687,39))). -user:metta_file_buffer(65,649002142,metta_other,[->,'Atom','Atom','Atom','%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1687,9),line_char(1687,40))). -user:metta_file_buffer(64,649002142,metta_typedecl,[:,match,[->,'Atom','Atom','Atom','%Undefined%']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1687,0),line_char(1687,41))). -user:metta_file_buffer(64,650002142,indexed(metta_comment,";(ALT= (match $space $pattern $template)"),'$COMMENT'(";(ALT= (match $space $pattern $template)",1689,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1689,0),line_char(1689,40))). -user:metta_file_buffer(64,650002142,indexed(metta_comment,"; (unify $space $pattern $template Empty))"),'$COMMENT'("; (unify $space $pattern $template Empty))",1690,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1690,0),line_char(1690,43))). -user:metta_file_buffer(65,650002143,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1692,1),line_char(1692,3))). -user:metta_file_buffer(65,650002143,constant,'register-module!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1692,4),line_char(1692,20))). -user:metta_file_buffer(65,650002143,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1692,21),line_char(1692,26))). -user:metta_file_buffer(64,650002143,metta_other,[iz,'register-module!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1692,0),line_char(1692,27))). -user:metta_file_buffer(65,651002144,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1693,1),line_char(1693,5))). -user:metta_file_buffer(65,651002144,constant,'register-module!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1693,6),line_char(1693,22))). -user:metta_file_buffer(66,651002145,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1694,3),line_char(1694,8))). -user:metta_file_buffer(66,651002145,string,"Takes a file system path (first argument) and loads the module into the runner",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1694,9),line_char(1694,89))). -user:metta_file_buffer(65,651002145,metta_other,['@desc',"Takes a file system path (first argument) and loads the module into the runner"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1694,2),line_char(1694,90))). -user:metta_file_buffer(66,651002146,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1695,3),line_char(1695,10))). -user:metta_file_buffer(68,651002148,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1696,5),line_char(1696,11))). -user:metta_file_buffer(68,651002148,string,"File system path",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1696,12),line_char(1696,30))). -user:metta_file_buffer(67,651002148,metta_other,['@param',"File system path"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1696,4),line_char(1696,31))). -user:metta_file_buffer(66,651002148,array,[['@param',"File system path"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1695,11),line_char(1696,32))). -user:metta_file_buffer(65,651002148,metta_other,['@params',[['@param',"File system path"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1695,2),line_char(1696,33))). -user:metta_file_buffer(66,651002149,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1697,3),line_char(1697,10))). -user:metta_file_buffer(66,651002149,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1697,11),line_char(1697,22))). -user:metta_file_buffer(65,651002149,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1697,2),line_char(1697,23))). -user:metta_file_buffer(64,651002149,metta_other,['@doc','register-module!',['@desc',"Takes a file system path (first argument) and loads the module into the runner"],['@params',[['@param',"File system path"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1693,0),line_char(1697,24))). -user:metta_file_buffer(65,652002150,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1698,1),line_char(1698,2))). -user:metta_file_buffer(65,652002150,constant,'register-module!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1698,3),line_char(1698,19))). -user:metta_file_buffer(66,652002151,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1698,21),line_char(1698,23))). -user:metta_file_buffer(66,652002151,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1698,24),line_char(1698,28))). -user:metta_file_buffer(67,652002152,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1698,30),line_char(1698,32))). -user:metta_file_buffer(66,652002152,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1698,29),line_char(1698,33))). -user:metta_file_buffer(65,652002152,metta_other,[->,'Atom',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1698,20),line_char(1698,34))). -user:metta_file_buffer(64,652002152,metta_typedecl,[:,'register-module!',[->,'Atom',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1698,0),line_char(1698,35))). -user:metta_file_buffer(65,653002153,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1701,1),line_char(1701,3))). -user:metta_file_buffer(65,653002153,constant,'mod-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1701,4),line_char(1701,14))). -user:metta_file_buffer(65,653002153,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1701,15),line_char(1701,20))). -user:metta_file_buffer(64,653002153,metta_other,[iz,'mod-space!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1701,0),line_char(1701,21))). -user:metta_file_buffer(65,654002154,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1702,1),line_char(1702,5))). -user:metta_file_buffer(65,654002154,constant,'mod-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1702,6),line_char(1702,16))). -user:metta_file_buffer(66,654002155,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1703,3),line_char(1703,8))). -user:metta_file_buffer(66,654002155,string,"Returns the space of the module (first argument) and tries to load the module if it is not loaded into the module system",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1703,9),line_char(1703,131))). -user:metta_file_buffer(65,654002155,metta_other,['@desc',"Returns the space of the module (first argument) and tries to load the module if it is not loaded into the module system"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1703,2),line_char(1703,132))). -user:metta_file_buffer(66,654002156,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1704,3),line_char(1704,10))). -user:metta_file_buffer(68,654002158,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1705,5),line_char(1705,11))). -user:metta_file_buffer(68,654002158,string,"Module name",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1705,12),line_char(1705,25))). -user:metta_file_buffer(67,654002158,metta_other,['@param',"Module name"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1705,4),line_char(1705,26))). -user:metta_file_buffer(66,654002158,array,[['@param',"Module name"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1704,11),line_char(1705,27))). -user:metta_file_buffer(65,654002158,metta_other,['@params',[['@param',"Module name"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1704,2),line_char(1705,28))). -user:metta_file_buffer(66,654002159,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1706,3),line_char(1706,10))). -user:metta_file_buffer(66,654002159,string,"Space name",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1706,11),line_char(1706,23))). -user:metta_file_buffer(65,654002159,metta_other,['@return',"Space name"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1706,2),line_char(1706,24))). -user:metta_file_buffer(64,654002159,metta_other,['@doc','mod-space!',['@desc',"Returns the space of the module (first argument) and tries to load the module if it is not loaded into the module system"],['@params',[['@param',"Module name"]]],['@return',"Space name"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1702,0),line_char(1706,25))). -user:metta_file_buffer(65,655002160,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1707,1),line_char(1707,2))). -user:metta_file_buffer(65,655002160,constant,'mod-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1707,3),line_char(1707,13))). -user:metta_file_buffer(66,655002161,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1707,15),line_char(1707,17))). -user:metta_file_buffer(66,655002161,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1707,18),line_char(1707,22))). -user:metta_file_buffer(66,655002161,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1707,23),line_char(1707,47))). -user:metta_file_buffer(65,655002161,metta_other,[->,'Atom','hyperon::space::DynSpace'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1707,14),line_char(1707,48))). -user:metta_file_buffer(64,655002161,metta_typedecl,[:,'mod-space!',[->,'Atom','hyperon::space::DynSpace']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1707,0),line_char(1707,49))). -user:metta_file_buffer(65,656002162,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1709,1),line_char(1709,2))). -user:metta_file_buffer(66,656002163,constant,'mod-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1709,4),line_char(1709,14))). -user:metta_file_buffer(66,656002163,constant,self,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1709,15),line_char(1709,19))). -user:metta_file_buffer(65,656002163,metta_directive,['mod-space!',self],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1709,3),line_char(1709,20))). -user:metta_file_buffer(65,656002163,constant,'&self',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1709,21),line_char(1709,26))). -user:metta_file_buffer(64,656002163,indexed(metta_defun,['mod-space!',self]),[=,['mod-space!',self],'&self'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1709,0),line_char(1709,27))). -user:metta_file_buffer(65,657002164,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1710,1),line_char(1710,2))). -user:metta_file_buffer(66,657002165,constant,'mod-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1710,4),line_char(1710,14))). -user:metta_file_buffer(66,657002165,constant,top,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1710,15),line_char(1710,18))). -user:metta_file_buffer(65,657002165,metta_directive,['mod-space!',top],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1710,3),line_char(1710,19))). -user:metta_file_buffer(65,657002165,constant,'&self',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1710,20),line_char(1710,25))). -user:metta_file_buffer(64,657002165,indexed(metta_defun,['mod-space!',top]),[=,['mod-space!',top],'&self'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1710,0),line_char(1710,26))). -user:metta_file_buffer(65,658002166,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1711,1),line_char(1711,2))). -user:metta_file_buffer(66,658002167,constant,'mod-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1711,4),line_char(1711,14))). -user:metta_file_buffer(66,658002167,constant,corelib,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1711,15),line_char(1711,22))). -user:metta_file_buffer(65,658002167,metta_directive,['mod-space!',corelib],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1711,3),line_char(1711,23))). -user:metta_file_buffer(65,658002167,constant,'&corelib',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1711,24),line_char(1711,32))). -user:metta_file_buffer(64,658002167,indexed(metta_defun,['mod-space!',corelib]),[=,['mod-space!',corelib],'&corelib'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1711,0),line_char(1711,33))). -user:metta_file_buffer(65,659002168,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1712,1),line_char(1712,2))). -user:metta_file_buffer(66,659002169,constant,'mod-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1712,4),line_char(1712,14))). -user:metta_file_buffer(66,659002169,constant,stdlib,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1712,15),line_char(1712,21))). -user:metta_file_buffer(65,659002169,metta_directive,['mod-space!',stdlib],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1712,3),line_char(1712,22))). -user:metta_file_buffer(65,659002169,constant,'&stdlib',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1712,23),line_char(1712,30))). -user:metta_file_buffer(64,659002169,indexed(metta_defun,['mod-space!',stdlib]),[=,['mod-space!',stdlib],'&stdlib'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1712,0),line_char(1712,31))). -user:metta_file_buffer(65,660002170,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1713,1),line_char(1713,2))). -user:metta_file_buffer(66,660002171,constant,'mod-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1713,4),line_char(1713,14))). -user:metta_file_buffer(66,660002171,constant,catalog,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1713,15),line_char(1713,22))). -user:metta_file_buffer(65,660002171,metta_directive,['mod-space!',catalog],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1713,3),line_char(1713,23))). -user:metta_file_buffer(65,660002171,constant,'&catalog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1713,24),line_char(1713,32))). -user:metta_file_buffer(64,660002171,indexed(metta_defun,['mod-space!',catalog]),[=,['mod-space!',catalog],'&catalog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1713,0),line_char(1713,33))). -user:metta_file_buffer(65,661002172,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1716,1),line_char(1716,3))). -user:metta_file_buffer(65,661002172,constant,'print-mods!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1716,4),line_char(1716,15))). -user:metta_file_buffer(65,661002172,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1716,16),line_char(1716,21))). -user:metta_file_buffer(64,661002172,metta_other,[iz,'print-mods!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1716,0),line_char(1716,22))). -user:metta_file_buffer(65,662002173,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1717,1),line_char(1717,5))). -user:metta_file_buffer(65,662002173,constant,'print-mods!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1717,6),line_char(1717,17))). -user:metta_file_buffer(66,662002174,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1718,3),line_char(1718,8))). -user:metta_file_buffer(66,662002174,string,"Prints all modules with their correspondent spaces",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1718,9),line_char(1718,61))). -user:metta_file_buffer(65,662002174,metta_other,['@desc',"Prints all modules with their correspondent spaces"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1718,2),line_char(1718,62))). -user:metta_file_buffer(66,662002175,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1719,3),line_char(1719,10))). -user:metta_file_buffer(66,662002176,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1719,11),line_char(1719,13))). -user:metta_file_buffer(65,662002176,metta_other,['@params',[]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1719,2),line_char(1719,14))). -user:metta_file_buffer(66,662002177,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1720,3),line_char(1720,10))). -user:metta_file_buffer(66,662002177,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1720,11),line_char(1720,22))). -user:metta_file_buffer(65,662002177,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1720,2),line_char(1720,23))). -user:metta_file_buffer(64,662002177,metta_other,['@doc','print-mods!',['@desc',"Prints all modules with their correspondent spaces"],['@params',[]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1717,0),line_char(1720,24))). -user:metta_file_buffer(65,663002178,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1721,1),line_char(1721,2))). -user:metta_file_buffer(65,663002178,constant,'print-mods!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1721,3),line_char(1721,14))). -user:metta_file_buffer(66,663002179,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1721,16),line_char(1721,18))). -user:metta_file_buffer(67,663002180,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1721,20),line_char(1721,22))). -user:metta_file_buffer(66,663002180,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1721,19),line_char(1721,23))). -user:metta_file_buffer(65,663002180,metta_other,[->,[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1721,15),line_char(1721,24))). -user:metta_file_buffer(64,663002180,metta_typedecl,[:,'print-mods!',[->,[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1721,0),line_char(1721,25))). -user:metta_file_buffer(65,664002181,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1724,1),line_char(1724,3))). -user:metta_file_buffer(65,664002181,constant,assertEqual,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1724,4),line_char(1724,15))). -user:metta_file_buffer(65,664002181,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1724,16),line_char(1724,21))). -user:metta_file_buffer(64,664002181,metta_other,[iz,assertEqual,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1724,0),line_char(1724,22))). -user:metta_file_buffer(65,665002182,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1725,1),line_char(1725,5))). -user:metta_file_buffer(65,665002182,constant,assertEqual,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1725,6),line_char(1725,17))). -user:metta_file_buffer(66,665002183,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1726,3),line_char(1726,8))). -user:metta_file_buffer(66,665002183,string,"Compares (sets of) results of evaluation of two expressions",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1726,9),line_char(1726,70))). -user:metta_file_buffer(65,665002183,metta_other,['@desc',"Compares (sets of) results of evaluation of two expressions"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1726,2),line_char(1726,71))). -user:metta_file_buffer(66,665002184,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1727,3),line_char(1727,10))). -user:metta_file_buffer(68,665002186,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1728,5),line_char(1728,11))). -user:metta_file_buffer(68,665002186,string,"First expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1728,12),line_char(1728,30))). -user:metta_file_buffer(67,665002186,metta_other,['@param',"First expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1728,4),line_char(1728,31))). -user:metta_file_buffer(68,665002187,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1729,5),line_char(1729,11))). -user:metta_file_buffer(68,665002187,string,"Second expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1729,12),line_char(1729,31))). -user:metta_file_buffer(67,665002187,metta_other,['@param',"Second expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1729,4),line_char(1729,32))). -user:metta_file_buffer(66,665002187,array,[['@param',"First expression"],['@param',"Second expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1727,11),line_char(1729,33))). -user:metta_file_buffer(65,665002187,metta_other,['@params',[['@param',"First expression"],['@param',"Second expression"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1727,2),line_char(1729,34))). -user:metta_file_buffer(66,665002188,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1730,3),line_char(1730,10))). -user:metta_file_buffer(66,665002188,string,"Unit atom if both expression after evaluation is equal, error - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1730,11),line_char(1730,86))). -user:metta_file_buffer(65,665002188,metta_other,['@return',"Unit atom if both expression after evaluation is equal, error - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1730,2),line_char(1730,87))). -user:metta_file_buffer(64,665002188,metta_other,['@doc',assertEqual,['@desc',"Compares (sets of) results of evaluation of two expressions"],['@params',[['@param',"First expression"],['@param',"Second expression"]]],['@return',"Unit atom if both expression after evaluation is equal, error - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1725,0),line_char(1730,88))). -user:metta_file_buffer(65,666002189,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1731,1),line_char(1731,2))). -user:metta_file_buffer(65,666002189,constant,assertEqual,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1731,3),line_char(1731,14))). -user:metta_file_buffer(66,666002190,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1731,16),line_char(1731,18))). -user:metta_file_buffer(66,666002190,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1731,19),line_char(1731,23))). -user:metta_file_buffer(66,666002190,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1731,24),line_char(1731,28))). -user:metta_file_buffer(66,666002190,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1731,29),line_char(1731,33))). -user:metta_file_buffer(65,666002190,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1731,15),line_char(1731,34))). -user:metta_file_buffer(64,666002190,metta_typedecl,[:,assertEqual,[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1731,0),line_char(1731,35))). -user:metta_file_buffer(65,667002191,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1733,1),line_char(1733,3))). -user:metta_file_buffer(65,667002191,constant,assertNotEqual,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1733,4),line_char(1733,18))). -user:metta_file_buffer(65,667002191,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1733,19),line_char(1733,27))). -user:metta_file_buffer(64,667002191,metta_other,[iz,assertNotEqual,'MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1733,0),line_char(1733,28))). -user:metta_file_buffer(65,668002192,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1734,1),line_char(1734,5))). -user:metta_file_buffer(65,668002192,constant,assertNotEqual,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1734,6),line_char(1734,20))). -user:metta_file_buffer(66,668002193,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1735,3),line_char(1735,8))). -user:metta_file_buffer(66,668002193,string,"Compares (sets of) results of evaluation of two expressions",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1735,9),line_char(1735,70))). -user:metta_file_buffer(65,668002193,metta_other,['@desc',"Compares (sets of) results of evaluation of two expressions"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1735,2),line_char(1735,71))). -user:metta_file_buffer(66,668002194,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1736,3),line_char(1736,10))). -user:metta_file_buffer(68,668002196,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1737,5),line_char(1737,11))). -user:metta_file_buffer(68,668002196,string,"First expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1737,12),line_char(1737,30))). -user:metta_file_buffer(67,668002196,metta_other,['@param',"First expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1737,4),line_char(1737,31))). -user:metta_file_buffer(68,668002197,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1738,5),line_char(1738,11))). -user:metta_file_buffer(68,668002197,string,"Second expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1738,12),line_char(1738,31))). -user:metta_file_buffer(67,668002197,metta_other,['@param',"Second expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1738,4),line_char(1738,32))). -user:metta_file_buffer(66,668002197,array,[['@param',"First expression"],['@param',"Second expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1736,11),line_char(1738,33))). -user:metta_file_buffer(65,668002197,metta_other,['@params',[['@param',"First expression"],['@param',"Second expression"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1736,2),line_char(1738,34))). -user:metta_file_buffer(66,668002198,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1739,3),line_char(1739,10))). -user:metta_file_buffer(66,668002198,string,"Unit atom if both expressions after evaluation are not equal, error - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1739,11),line_char(1739,92))). -user:metta_file_buffer(65,668002198,metta_other,['@return',"Unit atom if both expressions after evaluation are not equal, error - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1739,2),line_char(1739,93))). -user:metta_file_buffer(64,668002198,metta_other,['@doc',assertNotEqual,['@desc',"Compares (sets of) results of evaluation of two expressions"],['@params',[['@param',"First expression"],['@param',"Second expression"]]],['@return',"Unit atom if both expressions after evaluation are not equal, error - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1734,0),line_char(1739,94))). -user:metta_file_buffer(65,669002199,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1740,1),line_char(1740,2))). -user:metta_file_buffer(65,669002199,constant,assertNotEqual,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1740,3),line_char(1740,17))). -user:metta_file_buffer(66,669002200,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1740,19),line_char(1740,21))). -user:metta_file_buffer(66,669002200,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1740,22),line_char(1740,26))). -user:metta_file_buffer(66,669002200,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1740,27),line_char(1740,31))). -user:metta_file_buffer(66,669002200,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1740,32),line_char(1740,36))). -user:metta_file_buffer(65,669002200,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1740,18),line_char(1740,37))). -user:metta_file_buffer(64,669002200,metta_typedecl,[:,assertNotEqual,[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1740,0),line_char(1740,38))). -user:metta_file_buffer(65,670002201,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1743,1),line_char(1743,3))). -user:metta_file_buffer(65,670002201,constant,assertEqualToResult,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1743,4),line_char(1743,23))). -user:metta_file_buffer(65,670002201,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1743,24),line_char(1743,29))). -user:metta_file_buffer(64,670002201,metta_other,[iz,assertEqualToResult,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1743,0),line_char(1743,30))). -user:metta_file_buffer(65,671002202,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1744,1),line_char(1744,5))). -user:metta_file_buffer(65,671002202,constant,assertEqualToResult,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1744,6),line_char(1744,25))). -user:metta_file_buffer(66,671002203,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1745,3),line_char(1745,8))). -user:metta_file_buffer(66,671002203,string,"Same as assertEqual but it doesn't evaluate second argument. Second argument is considered as a set of values of the first argument's evaluation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1745,9),line_char(1745,155))). -user:metta_file_buffer(65,671002203,metta_other,['@desc',"Same as assertEqual but it doesn't evaluate second argument. Second argument is considered as a set of values of the first argument's evaluation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1745,2),line_char(1745,156))). -user:metta_file_buffer(66,671002204,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1746,3),line_char(1746,10))). -user:metta_file_buffer(68,671002206,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1747,5),line_char(1747,11))). -user:metta_file_buffer(68,671002206,string,"First expression (it will be evaluated)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1747,12),line_char(1747,53))). -user:metta_file_buffer(67,671002206,metta_other,['@param',"First expression (it will be evaluated)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1747,4),line_char(1747,54))). -user:metta_file_buffer(68,671002207,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1748,5),line_char(1748,11))). -user:metta_file_buffer(68,671002207,string,"Second expression (it won't be evaluated)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1748,12),line_char(1748,55))). -user:metta_file_buffer(67,671002207,metta_other,['@param',"Second expression (it won't be evaluated)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1748,4),line_char(1748,56))). -user:metta_file_buffer(66,671002207,array,[['@param',"First expression (it will be evaluated)"],['@param',"Second expression (it won't be evaluated)"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1746,11),line_char(1748,57))). -user:metta_file_buffer(65,671002207,metta_other,['@params',[['@param',"First expression (it will be evaluated)"],['@param',"Second expression (it won't be evaluated)"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1746,2),line_char(1748,58))). -user:metta_file_buffer(66,671002208,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1749,3),line_char(1749,10))). -user:metta_file_buffer(66,671002208,string,"Unit atom if both expression after evaluation is equal, error - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1749,11),line_char(1749,86))). -user:metta_file_buffer(65,671002208,metta_other,['@return',"Unit atom if both expression after evaluation is equal, error - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1749,2),line_char(1749,87))). -user:metta_file_buffer(64,671002208,metta_other,['@doc',assertEqualToResult,['@desc',"Same as assertEqual but it doesn't evaluate second argument. Second argument is considered as a set of values of the first argument's evaluation"],['@params',[['@param',"First expression (it will be evaluated)"],['@param',"Second expression (it won't be evaluated)"]]],['@return',"Unit atom if both expression after evaluation is equal, error - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1744,0),line_char(1749,88))). -user:metta_file_buffer(65,672002209,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1750,1),line_char(1750,2))). -user:metta_file_buffer(65,672002209,constant,assertEqualToResult,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1750,3),line_char(1750,22))). -user:metta_file_buffer(66,672002210,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1750,24),line_char(1750,26))). -user:metta_file_buffer(66,672002210,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1750,27),line_char(1750,31))). -user:metta_file_buffer(66,672002210,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1750,32),line_char(1750,36))). -user:metta_file_buffer(66,672002210,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1750,37),line_char(1750,41))). -user:metta_file_buffer(65,672002210,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1750,23),line_char(1750,42))). -user:metta_file_buffer(64,672002210,metta_typedecl,[:,assertEqualToResult,[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1750,0),line_char(1750,43))). -user:metta_file_buffer(65,673002211,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1753,1),line_char(1753,3))). -user:metta_file_buffer(65,673002211,constant,assertNotEqualToResult,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1753,4),line_char(1753,26))). -user:metta_file_buffer(65,673002211,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1753,27),line_char(1753,35))). -user:metta_file_buffer(64,673002211,metta_other,[iz,assertNotEqualToResult,'MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1753,0),line_char(1753,36))). -user:metta_file_buffer(65,674002212,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1754,1),line_char(1754,5))). -user:metta_file_buffer(65,674002212,constant,assertNotEqualToResult,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1754,6),line_char(1754,28))). -user:metta_file_buffer(66,674002213,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1755,3),line_char(1755,8))). -user:metta_file_buffer(66,674002213,string,"Same as assertNotEqual but it doesn't evaluate second argument. Second argument is considered as a set of values of the first argument's evaluation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1755,9),line_char(1755,158))). -user:metta_file_buffer(65,674002213,metta_other,['@desc',"Same as assertNotEqual but it doesn't evaluate second argument. Second argument is considered as a set of values of the first argument's evaluation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1755,2),line_char(1755,159))). -user:metta_file_buffer(66,674002214,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1756,3),line_char(1756,10))). -user:metta_file_buffer(68,674002216,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1757,5),line_char(1757,11))). -user:metta_file_buffer(68,674002216,string,"First expression (it will be evaluated)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1757,12),line_char(1757,53))). -user:metta_file_buffer(67,674002216,metta_other,['@param',"First expression (it will be evaluated)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1757,4),line_char(1757,54))). -user:metta_file_buffer(68,674002217,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1758,5),line_char(1758,11))). -user:metta_file_buffer(68,674002217,string,"Second expression (it won't be evaluated)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1758,12),line_char(1758,55))). -user:metta_file_buffer(67,674002217,metta_other,['@param',"Second expression (it won't be evaluated)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1758,4),line_char(1758,56))). -user:metta_file_buffer(66,674002217,array,[['@param',"First expression (it will be evaluated)"],['@param',"Second expression (it won't be evaluated)"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1756,11),line_char(1758,57))). -user:metta_file_buffer(65,674002217,metta_other,['@params',[['@param',"First expression (it will be evaluated)"],['@param',"Second expression (it won't be evaluated)"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1756,2),line_char(1758,58))). -user:metta_file_buffer(66,674002218,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1759,3),line_char(1759,10))). -user:metta_file_buffer(66,674002218,string,"Unit atom if both expressions after evaluation are not equal, error - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1759,11),line_char(1759,92))). -user:metta_file_buffer(65,674002218,metta_other,['@return',"Unit atom if both expressions after evaluation are not equal, error - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1759,2),line_char(1759,93))). -user:metta_file_buffer(64,674002218,metta_other,['@doc',assertNotEqualToResult,['@desc',"Same as assertNotEqual but it doesn't evaluate second argument. Second argument is considered as a set of values of the first argument's evaluation"],['@params',[['@param',"First expression (it will be evaluated)"],['@param',"Second expression (it won't be evaluated)"]]],['@return',"Unit atom if both expressions after evaluation are not equal, error - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1754,0),line_char(1759,94))). -user:metta_file_buffer(65,675002219,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1760,1),line_char(1760,2))). -user:metta_file_buffer(65,675002219,constant,assertNotEqualToResult,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1760,3),line_char(1760,25))). -user:metta_file_buffer(66,675002220,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1760,27),line_char(1760,29))). -user:metta_file_buffer(66,675002220,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1760,30),line_char(1760,34))). -user:metta_file_buffer(66,675002220,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1760,35),line_char(1760,39))). -user:metta_file_buffer(66,675002220,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1760,40),line_char(1760,44))). -user:metta_file_buffer(65,675002220,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1760,26),line_char(1760,45))). -user:metta_file_buffer(64,675002220,metta_typedecl,[:,assertNotEqualToResult,[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1760,0),line_char(1760,46))). -user:metta_file_buffer(65,676002221,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1763,1),line_char(1763,3))). -user:metta_file_buffer(65,676002221,constant,superpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1763,4),line_char(1763,13))). -user:metta_file_buffer(65,676002221,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1763,14),line_char(1763,19))). -user:metta_file_buffer(64,676002221,metta_other,[iz,superpose,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1763,0),line_char(1763,20))). -user:metta_file_buffer(65,677002222,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1764,1),line_char(1764,5))). -user:metta_file_buffer(65,677002222,constant,superpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1764,6),line_char(1764,15))). -user:metta_file_buffer(66,677002223,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1765,3),line_char(1765,8))). -user:metta_file_buffer(66,677002223,string,"Turns a tuple (first argument) into a nondeterministic result",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1765,9),line_char(1765,72))). -user:metta_file_buffer(65,677002223,metta_other,['@desc',"Turns a tuple (first argument) into a nondeterministic result"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1765,2),line_char(1765,73))). -user:metta_file_buffer(66,677002224,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1766,3),line_char(1766,10))). -user:metta_file_buffer(68,677002226,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1767,5),line_char(1767,11))). -user:metta_file_buffer(68,677002226,string,"Tuple to be converted",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1767,12),line_char(1767,35))). -user:metta_file_buffer(67,677002226,metta_other,['@param',"Tuple to be converted"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1767,4),line_char(1767,36))). -user:metta_file_buffer(66,677002226,array,[['@param',"Tuple to be converted"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1766,11),line_char(1767,37))). -user:metta_file_buffer(65,677002226,metta_other,['@params',[['@param',"Tuple to be converted"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1766,2),line_char(1767,38))). -user:metta_file_buffer(66,677002227,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1768,3),line_char(1768,10))). -user:metta_file_buffer(66,677002227,string,"Argument converted to nondeterministic result",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1768,11),line_char(1768,58))). -user:metta_file_buffer(65,677002227,metta_other,['@return',"Argument converted to nondeterministic result"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1768,2),line_char(1768,59))). -user:metta_file_buffer(64,677002227,metta_other,['@doc',superpose,['@desc',"Turns a tuple (first argument) into a nondeterministic result"],['@params',[['@param',"Tuple to be converted"]]],['@return',"Argument converted to nondeterministic result"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1764,0),line_char(1768,60))). -user:metta_file_buffer(65,678002228,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1769,1),line_char(1769,2))). -user:metta_file_buffer(65,678002228,constant,superpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1769,3),line_char(1769,12))). -user:metta_file_buffer(66,678002229,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1769,14),line_char(1769,16))). -user:metta_file_buffer(66,678002229,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1769,17),line_char(1769,27))). -user:metta_file_buffer(66,678002229,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1769,28),line_char(1769,39))). -user:metta_file_buffer(65,678002229,metta_other,[->,'Expression','%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1769,13),line_char(1769,40))). -user:metta_file_buffer(64,678002229,metta_typedecl,[:,superpose,[->,'Expression','%Undefined%']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1769,0),line_char(1769,41))). -user:metta_file_buffer(65,679002230,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1771,1),line_char(1771,3))). -user:metta_file_buffer(65,679002230,constant,collapse,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1771,4),line_char(1771,12))). -user:metta_file_buffer(65,679002230,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1771,13),line_char(1771,18))). -user:metta_file_buffer(64,679002230,metta_other,[iz,collapse,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1771,0),line_char(1771,19))). -user:metta_file_buffer(65,680002231,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1772,1),line_char(1772,5))). -user:metta_file_buffer(65,680002231,constant,collapse,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1772,6),line_char(1772,14))). -user:metta_file_buffer(66,680002232,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1773,3),line_char(1773,8))). -user:metta_file_buffer(66,680002232,string,"Converts a nondeterministic result into a tuple",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1773,9),line_char(1773,58))). -user:metta_file_buffer(65,680002232,metta_other,['@desc',"Converts a nondeterministic result into a tuple"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1773,2),line_char(1773,59))). -user:metta_file_buffer(66,680002233,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1774,3),line_char(1774,10))). -user:metta_file_buffer(68,680002235,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1775,5),line_char(1775,11))). -user:metta_file_buffer(68,680002235,string,"Atom which will be evaluated",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1775,12),line_char(1775,42))). -user:metta_file_buffer(67,680002235,metta_other,['@param',"Atom which will be evaluated"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1775,4),line_char(1775,43))). -user:metta_file_buffer(66,680002235,array,[['@param',"Atom which will be evaluated"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1774,11),line_char(1775,44))). -user:metta_file_buffer(65,680002235,metta_other,['@params',[['@param',"Atom which will be evaluated"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1774,2),line_char(1775,45))). -user:metta_file_buffer(66,680002236,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1776,3),line_char(1776,10))). -user:metta_file_buffer(66,680002236,string,"Tuple",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1776,11),line_char(1776,18))). -user:metta_file_buffer(65,680002236,metta_other,['@return',"Tuple"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1776,2),line_char(1776,19))). -user:metta_file_buffer(64,680002236,metta_other,['@doc',collapse,['@desc',"Converts a nondeterministic result into a tuple"],['@params',[['@param',"Atom which will be evaluated"]]],['@return',"Tuple"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1772,0),line_char(1776,20))). -user:metta_file_buffer(65,681002237,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1777,1),line_char(1777,2))). -user:metta_file_buffer(65,681002237,constant,collapse,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1777,3),line_char(1777,11))). -user:metta_file_buffer(66,681002238,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1777,13),line_char(1777,15))). -user:metta_file_buffer(66,681002238,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1777,16),line_char(1777,20))). -user:metta_file_buffer(66,681002238,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1777,21),line_char(1777,25))). -user:metta_file_buffer(65,681002238,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1777,12),line_char(1777,26))). -user:metta_file_buffer(64,681002238,metta_typedecl,[:,collapse,[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1777,0),line_char(1777,27))). -user:metta_file_buffer(65,682002239,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1779,1),line_char(1779,3))). -user:metta_file_buffer(65,682002239,constant,case,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1779,4),line_char(1779,8))). -user:metta_file_buffer(65,682002239,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1779,9),line_char(1779,14))). -user:metta_file_buffer(64,682002239,metta_other,[iz,case,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1779,0),line_char(1779,15))). -user:metta_file_buffer(65,683002240,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1780,1),line_char(1780,5))). -user:metta_file_buffer(65,683002240,constant,case,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1780,6),line_char(1780,10))). -user:metta_file_buffer(66,683002241,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1781,3),line_char(1781,8))). -user:metta_file_buffer(66,683002241,string,"Subsequently tests multiple pattern-matching conditions (second argument) for the given value (first argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1781,9),line_char(1781,121))). -user:metta_file_buffer(65,683002241,metta_other,['@desc',"Subsequently tests multiple pattern-matching conditions (second argument) for the given value (first argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1781,2),line_char(1781,122))). -user:metta_file_buffer(66,683002242,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1782,3),line_char(1782,10))). -user:metta_file_buffer(68,683002244,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1783,5),line_char(1783,11))). -user:metta_file_buffer(68,683002244,string,"Atom (it will be evaluated)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1783,12),line_char(1783,41))). -user:metta_file_buffer(67,683002244,metta_other,['@param',"Atom (it will be evaluated)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1783,4),line_char(1783,42))). -user:metta_file_buffer(68,683002245,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1784,5),line_char(1784,11))). -user:metta_file_buffer(68,683002245,string,"Tuple of pairs mapping condition patterns to results",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1784,12),line_char(1784,66))). -user:metta_file_buffer(67,683002245,metta_other,['@param',"Tuple of pairs mapping condition patterns to results"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1784,4),line_char(1784,67))). -user:metta_file_buffer(66,683002245,array,[['@param',"Atom (it will be evaluated)"],['@param',"Tuple of pairs mapping condition patterns to results"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1782,11),line_char(1784,68))). -user:metta_file_buffer(65,683002245,metta_other,['@params',[['@param',"Atom (it will be evaluated)"],['@param',"Tuple of pairs mapping condition patterns to results"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1782,2),line_char(1784,69))). -user:metta_file_buffer(66,683002246,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1785,3),line_char(1785,10))). -user:metta_file_buffer(66,683002246,string,"Result of evaluating Atom bound to met condition",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1785,11),line_char(1785,61))). -user:metta_file_buffer(65,683002246,metta_other,['@return',"Result of evaluating Atom bound to met condition"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1785,2),line_char(1785,62))). -user:metta_file_buffer(64,683002246,metta_other,['@doc',case,['@desc',"Subsequently tests multiple pattern-matching conditions (second argument) for the given value (first argument)"],['@params',[['@param',"Atom (it will be evaluated)"],['@param',"Tuple of pairs mapping condition patterns to results"]]],['@return',"Result of evaluating Atom bound to met condition"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1780,0),line_char(1785,63))). -user:metta_file_buffer(65,684002247,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1786,1),line_char(1786,2))). -user:metta_file_buffer(65,684002247,constant,case,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1786,3),line_char(1786,7))). -user:metta_file_buffer(66,684002248,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1786,9),line_char(1786,11))). -user:metta_file_buffer(66,684002248,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1786,12),line_char(1786,16))). -user:metta_file_buffer(66,684002248,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1786,17),line_char(1786,27))). -user:metta_file_buffer(66,684002248,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1786,28),line_char(1786,32))). -user:metta_file_buffer(65,684002248,metta_other,[->,'Atom','Expression','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1786,8),line_char(1786,33))). -user:metta_file_buffer(64,684002248,metta_typedecl,[:,case,[->,'Atom','Expression','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1786,0),line_char(1786,34))). -user:metta_file_buffer(65,685002249,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1788,1),line_char(1788,3))). -user:metta_file_buffer(65,685002249,constant,capture,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1788,4),line_char(1788,11))). -user:metta_file_buffer(65,685002249,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1788,12),line_char(1788,17))). -user:metta_file_buffer(64,685002249,metta_other,[iz,capture,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1788,0),line_char(1788,18))). -user:metta_file_buffer(65,686002250,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1789,1),line_char(1789,5))). -user:metta_file_buffer(65,686002250,constant,capture,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1789,6),line_char(1789,13))). -user:metta_file_buffer(66,686002251,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1790,3),line_char(1790,8))). -user:metta_file_buffer(66,686002251,string,"Wraps an atom and captures the current space",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1790,9),line_char(1790,55))). -user:metta_file_buffer(65,686002251,metta_other,['@desc',"Wraps an atom and captures the current space"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1790,2),line_char(1790,56))). -user:metta_file_buffer(66,686002252,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1791,3),line_char(1791,10))). -user:metta_file_buffer(68,686002254,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1792,5),line_char(1792,11))). -user:metta_file_buffer(68,686002254,string,"Function name which space needs to be captured",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1792,12),line_char(1792,60))). -user:metta_file_buffer(67,686002254,metta_other,['@param',"Function name which space needs to be captured"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1792,4),line_char(1792,61))). -user:metta_file_buffer(66,686002254,array,[['@param',"Function name which space needs to be captured"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1791,11),line_char(1792,62))). -user:metta_file_buffer(65,686002254,metta_other,['@params',[['@param',"Function name which space needs to be captured"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1791,2),line_char(1792,63))). -user:metta_file_buffer(66,686002255,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1793,3),line_char(1793,10))). -user:metta_file_buffer(66,686002255,string,"Function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1793,11),line_char(1793,21))). -user:metta_file_buffer(65,686002255,metta_other,['@return',"Function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1793,2),line_char(1793,22))). -user:metta_file_buffer(64,686002255,metta_other,['@doc',capture,['@desc',"Wraps an atom and captures the current space"],['@params',[['@param',"Function name which space needs to be captured"]]],['@return',"Function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1789,0),line_char(1793,23))). -user:metta_file_buffer(65,687002256,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1794,1),line_char(1794,2))). -user:metta_file_buffer(65,687002256,constant,capture,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1794,3),line_char(1794,10))). -user:metta_file_buffer(66,687002257,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1794,12),line_char(1794,14))). -user:metta_file_buffer(66,687002257,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1794,15),line_char(1794,19))). -user:metta_file_buffer(66,687002257,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1794,20),line_char(1794,24))). -user:metta_file_buffer(65,687002257,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1794,11),line_char(1794,25))). -user:metta_file_buffer(64,687002257,metta_typedecl,[:,capture,[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1794,0),line_char(1794,26))). -user:metta_file_buffer(65,688002258,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1796,1),line_char(1796,3))). -user:metta_file_buffer(65,688002258,constant,hyperpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1796,4),line_char(1796,13))). -user:metta_file_buffer(65,688002258,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1796,14),line_char(1796,19))). -user:metta_file_buffer(64,688002258,metta_other,[iz,hyperpose,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1796,0),line_char(1796,20))). -user:metta_file_buffer(65,689002259,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1797,1),line_char(1797,5))). -user:metta_file_buffer(65,689002259,constant,hyperpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1797,6),line_char(1797,15))). -user:metta_file_buffer(66,689002260,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1798,3),line_char(1798,8))). -user:metta_file_buffer(66,689002260,string,"Turns a tuple (first argument) into a nondeterministic result, as superpose, but is explicitly concurrent. Each item of the tuple may be processed in parallel, depending on the number of threads available (which is the minimum of the tuple size and the number of cores available).",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1798,9),line_char(1798,291))). -user:metta_file_buffer(65,689002260,metta_other,['@desc',"Turns a tuple (first argument) into a nondeterministic result, as superpose, but is explicitly concurrent. Each item of the tuple may be processed in parallel, depending on the number of threads available (which is the minimum of the tuple size and the number of cores available)."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1798,2),line_char(1798,292))). -user:metta_file_buffer(66,689002261,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1799,3),line_char(1799,10))). -user:metta_file_buffer(68,689002263,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1800,5),line_char(1800,11))). -user:metta_file_buffer(68,689002263,string,"Tuple to be converted",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1800,12),line_char(1800,35))). -user:metta_file_buffer(67,689002263,metta_other,['@param',"Tuple to be converted"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1800,4),line_char(1800,36))). -user:metta_file_buffer(66,689002263,array,[['@param',"Tuple to be converted"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1799,11),line_char(1800,37))). -user:metta_file_buffer(65,689002263,metta_other,['@params',[['@param',"Tuple to be converted"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1799,2),line_char(1800,38))). -user:metta_file_buffer(66,689002264,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1801,3),line_char(1801,10))). -user:metta_file_buffer(66,689002264,string,"Argument converted to nondeterministic result",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1801,11),line_char(1801,58))). -user:metta_file_buffer(65,689002264,metta_other,['@return',"Argument converted to nondeterministic result"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1801,2),line_char(1801,59))). -user:metta_file_buffer(64,689002264,metta_other,['@doc',hyperpose,['@desc',"Turns a tuple (first argument) into a nondeterministic result, as superpose, but is explicitly concurrent. Each item of the tuple may be processed in parallel, depending on the number of threads available (which is the minimum of the tuple size and the number of cores available)."],['@params',[['@param',"Tuple to be converted"]]],['@return',"Argument converted to nondeterministic result"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1797,0),line_char(1801,60))). -user:metta_file_buffer(65,690002265,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1802,1),line_char(1802,2))). -user:metta_file_buffer(65,690002265,constant,hyperpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1802,3),line_char(1802,12))). -user:metta_file_buffer(66,690002266,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1802,14),line_char(1802,16))). -user:metta_file_buffer(66,690002266,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1802,17),line_char(1802,27))). -user:metta_file_buffer(66,690002266,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1802,28),line_char(1802,39))). -user:metta_file_buffer(65,690002266,metta_other,[->,'Expression','%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1802,13),line_char(1802,40))). -user:metta_file_buffer(64,690002266,metta_typedecl,[:,hyperpose,[->,'Expression','%Undefined%']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1802,0),line_char(1802,41))). -user:metta_file_buffer(65,691002267,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1804,1),line_char(1804,3))). -user:metta_file_buffer(65,691002267,constant,sequential,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1804,4),line_char(1804,14))). -user:metta_file_buffer(65,691002267,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1804,15),line_char(1804,20))). -user:metta_file_buffer(64,691002267,metta_other,[iz,sequential,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1804,0),line_char(1804,21))). -user:metta_file_buffer(65,692002268,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1805,1),line_char(1805,5))). -user:metta_file_buffer(65,692002268,constant,sequential,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1805,6),line_char(1805,16))). -user:metta_file_buffer(66,692002269,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1806,3),line_char(1806,8))). -user:metta_file_buffer(66,692002269,string,"Turns a tuple (first argument) into a nondeterministic result, as superpose, but evaluation order of the elements of the tuple is fixed left to right. In that sense the result order is deterministic iff evaluating the tuple elements is deterministic.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1806,9),line_char(1806,261))). -user:metta_file_buffer(65,692002269,metta_other,['@desc',"Turns a tuple (first argument) into a nondeterministic result, as superpose, but evaluation order of the elements of the tuple is fixed left to right. In that sense the result order is deterministic iff evaluating the tuple elements is deterministic."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1806,2),line_char(1806,262))). -user:metta_file_buffer(66,692002270,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1807,3),line_char(1807,10))). -user:metta_file_buffer(68,692002272,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1808,5),line_char(1808,11))). -user:metta_file_buffer(68,692002272,string,"Tuple to be evaluated",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1808,12),line_char(1808,35))). -user:metta_file_buffer(67,692002272,metta_other,['@param',"Tuple to be evaluated"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1808,4),line_char(1808,36))). -user:metta_file_buffer(66,692002272,array,[['@param',"Tuple to be evaluated"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1807,11),line_char(1808,37))). -user:metta_file_buffer(65,692002272,metta_other,['@params',[['@param',"Tuple to be evaluated"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1807,2),line_char(1808,38))). -user:metta_file_buffer(66,692002273,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1809,3),line_char(1809,10))). -user:metta_file_buffer(66,692002273,string,"Sequential results of the tuple's elements.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1809,11),line_char(1809,56))). -user:metta_file_buffer(65,692002273,metta_other,['@return',"Sequential results of the tuple's elements."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1809,2),line_char(1809,57))). -user:metta_file_buffer(64,692002273,metta_other,['@doc',sequential,['@desc',"Turns a tuple (first argument) into a nondeterministic result, as superpose, but evaluation order of the elements of the tuple is fixed left to right. In that sense the result order is deterministic iff evaluating the tuple elements is deterministic."],['@params',[['@param',"Tuple to be evaluated"]]],['@return',"Sequential results of the tuple's elements."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1805,0),line_char(1809,58))). -user:metta_file_buffer(65,693002274,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1810,1),line_char(1810,2))). -user:metta_file_buffer(65,693002274,constant,sequential,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1810,3),line_char(1810,13))). -user:metta_file_buffer(66,693002275,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1810,15),line_char(1810,17))). -user:metta_file_buffer(66,693002275,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1810,18),line_char(1810,28))). -user:metta_file_buffer(66,693002275,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1810,29),line_char(1810,40))). -user:metta_file_buffer(65,693002275,metta_other,[->,'Expression','%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1810,14),line_char(1810,41))). -user:metta_file_buffer(64,693002275,metta_typedecl,[:,sequential,[->,'Expression','%Undefined%']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1810,0),line_char(1810,42))). -user:metta_file_buffer(65,694002276,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1812,1),line_char(1812,3))). -user:metta_file_buffer(65,694002276,constant,do,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1812,4),line_char(1812,6))). -user:metta_file_buffer(65,694002276,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1812,7),line_char(1812,12))). -user:metta_file_buffer(64,694002276,metta_other,[iz,do,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1812,0),line_char(1812,13))). -user:metta_file_buffer(65,695002277,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1813,1),line_char(1813,5))). -user:metta_file_buffer(65,695002277,constant,do,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1813,6),line_char(1813,8))). -user:metta_file_buffer(66,695002278,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1814,3),line_char(1814,8))). -user:metta_file_buffer(66,695002278,string,"Completely evaluates form, returning nothing. Typically used for side-effects. A common pattern is (sequential ((do ) )).",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1814,9),line_char(1814,179))). -user:metta_file_buffer(65,695002278,metta_other,['@desc',"Completely evaluates form, returning nothing. Typically used for side-effects. A common pattern is (sequential ((do ) ))."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1814,2),line_char(1814,180))). -user:metta_file_buffer(66,695002279,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1815,3),line_char(1815,10))). -user:metta_file_buffer(68,695002281,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1816,5),line_char(1816,11))). -user:metta_file_buffer(68,695002281,string,"Form",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1816,12),line_char(1816,18))). -user:metta_file_buffer(67,695002281,metta_other,['@param',"Form"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1816,4),line_char(1816,19))). -user:metta_file_buffer(66,695002281,array,[['@param',"Form"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1815,11),line_char(1816,20))). -user:metta_file_buffer(65,695002281,metta_other,['@params',[['@param',"Form"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1815,2),line_char(1816,21))). -user:metta_file_buffer(66,695002282,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1817,3),line_char(1817,10))). -user:metta_file_buffer(66,695002282,string,"None",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1817,11),line_char(1817,17))). -user:metta_file_buffer(65,695002282,metta_other,['@return',"None"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1817,2),line_char(1817,18))). -user:metta_file_buffer(64,695002282,metta_other,['@doc',do,['@desc',"Completely evaluates form, returning nothing. Typically used for side-effects. A common pattern is (sequential ((do ) ))."],['@params',[['@param',"Form"]]],['@return',"None"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1813,0),line_char(1817,19))). -user:metta_file_buffer(65,696002283,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1818,1),line_char(1818,2))). -user:metta_file_buffer(65,696002283,constant,do,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1818,3),line_char(1818,5))). -user:metta_file_buffer(66,696002284,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1818,7),line_char(1818,9))). -user:metta_file_buffer(66,696002284,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1818,10),line_char(1818,20))). -user:metta_file_buffer(66,696002284,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1818,21),line_char(1818,32))). -user:metta_file_buffer(65,696002284,metta_other,[->,'Expression','%Undefined%'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1818,6),line_char(1818,33))). -user:metta_file_buffer(64,696002284,metta_typedecl,[:,do,[->,'Expression','%Undefined%']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1818,0),line_char(1818,34))). -user:metta_file_buffer(65,697002285,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1820,1),line_char(1820,3))). -user:metta_file_buffer(65,697002285,constant,'pragma!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1820,4),line_char(1820,11))). -user:metta_file_buffer(65,697002285,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1820,12),line_char(1820,17))). -user:metta_file_buffer(64,697002285,metta_other,[iz,'pragma!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1820,0),line_char(1820,18))). -user:metta_file_buffer(65,698002286,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1821,1),line_char(1821,5))). -user:metta_file_buffer(65,698002286,constant,'pragma!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1821,6),line_char(1821,13))). -user:metta_file_buffer(66,698002287,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1822,3),line_char(1822,8))). -user:metta_file_buffer(66,698002287,string,"Changes global key's (first argument) value to a new one (second argument)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1822,9),line_char(1822,85))). -user:metta_file_buffer(65,698002287,metta_other,['@desc',"Changes global key's (first argument) value to a new one (second argument)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1822,2),line_char(1822,86))). -user:metta_file_buffer(66,698002288,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1823,3),line_char(1823,10))). -user:metta_file_buffer(68,698002290,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1824,5),line_char(1824,11))). -user:metta_file_buffer(68,698002290,string,"Key's name",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1824,12),line_char(1824,24))). -user:metta_file_buffer(67,698002290,metta_other,['@param',"Key's name"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1824,4),line_char(1824,25))). -user:metta_file_buffer(68,698002291,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1825,5),line_char(1825,11))). -user:metta_file_buffer(68,698002291,string,"New value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1825,12),line_char(1825,23))). -user:metta_file_buffer(67,698002291,metta_other,['@param',"New value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1825,4),line_char(1825,24))). -user:metta_file_buffer(66,698002291,array,[['@param',"Key's name"],['@param',"New value"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1823,11),line_char(1825,25))). -user:metta_file_buffer(65,698002291,metta_other,['@params',[['@param',"Key's name"],['@param',"New value"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1823,2),line_char(1825,26))). -user:metta_file_buffer(66,698002292,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1826,3),line_char(1826,10))). -user:metta_file_buffer(66,698002292,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1826,11),line_char(1826,22))). -user:metta_file_buffer(65,698002292,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1826,2),line_char(1826,23))). -user:metta_file_buffer(64,698002292,metta_other,['@doc','pragma!',['@desc',"Changes global key's (first argument) value to a new one (second argument)"],['@params',[['@param',"Key's name"],['@param',"New value"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1821,0),line_char(1826,24))). -user:metta_file_buffer(65,699002293,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1827,1),line_char(1827,2))). -user:metta_file_buffer(65,699002293,constant,'pragma!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1827,3),line_char(1827,10))). -user:metta_file_buffer(66,699002294,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1827,12),line_char(1827,14))). -user:metta_file_buffer(66,699002294,constant,'Symbol',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1827,15),line_char(1827,21))). -user:metta_file_buffer(66,699002294,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1827,22),line_char(1827,33))). -user:metta_file_buffer(67,699002295,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1827,35),line_char(1827,37))). -user:metta_file_buffer(66,699002295,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1827,34),line_char(1827,38))). -user:metta_file_buffer(65,699002295,metta_other,[->,'Symbol','%Undefined%',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1827,11),line_char(1827,39))). -user:metta_file_buffer(64,699002295,metta_typedecl,[:,'pragma!',[->,'Symbol','%Undefined%',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1827,0),line_char(1827,40))). -user:metta_file_buffer(65,700002296,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1830,1),line_char(1830,3))). -user:metta_file_buffer(65,700002296,constant,'import!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1830,4),line_char(1830,11))). -user:metta_file_buffer(65,700002296,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1830,12),line_char(1830,17))). -user:metta_file_buffer(64,700002296,metta_other,[iz,'import!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1830,0),line_char(1830,18))). -user:metta_file_buffer(65,701002297,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1831,1),line_char(1831,5))). -user:metta_file_buffer(65,701002297,constant,'import!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1831,6),line_char(1831,13))). -user:metta_file_buffer(66,701002298,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1832,3),line_char(1832,8))). -user:metta_file_buffer(66,701002298,string,"Imports module using its relative path (second argument) and binds it to the token (first argument) which will represent imported atomspace. If first argument is &self then everything will be imported to current atomspace. The source is imported only the first time import! is called. Can load Python code (.py) or MeTTa (.metta); if ambiguous, assumes Python.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1832,9),line_char(1832,371))). -user:metta_file_buffer(65,701002298,metta_other,['@desc',"Imports module using its relative path (second argument) and binds it to the token (first argument) which will represent imported atomspace. If first argument is &self then everything will be imported to current atomspace. The source is imported only the first time import! is called. Can load Python code (.py) or MeTTa (.metta); if ambiguous, assumes Python."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1832,2),line_char(1832,372))). -user:metta_file_buffer(66,701002299,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1833,3),line_char(1833,10))). -user:metta_file_buffer(68,701002301,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1834,5),line_char(1834,11))). -user:metta_file_buffer(68,701002301,string,"Symbol, which is turned into the token for accessing the imported module",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1834,12),line_char(1834,86))). -user:metta_file_buffer(67,701002301,metta_other,['@param',"Symbol, which is turned into the token for accessing the imported module"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1834,4),line_char(1834,87))). -user:metta_file_buffer(68,701002302,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1835,5),line_char(1835,11))). -user:metta_file_buffer(68,701002302,string,"Module name",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1835,12),line_char(1835,25))). -user:metta_file_buffer(67,701002302,metta_other,['@param',"Module name"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1835,4),line_char(1835,26))). -user:metta_file_buffer(66,701002302,array,[['@param',"Symbol, which is turned into the token for accessing the imported module"],['@param',"Module name"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1833,11),line_char(1835,27))). -user:metta_file_buffer(65,701002302,metta_other,['@params',[['@param',"Symbol, which is turned into the token for accessing the imported module"],['@param',"Module name"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1833,2),line_char(1835,28))). -user:metta_file_buffer(66,701002303,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1836,3),line_char(1836,10))). -user:metta_file_buffer(66,701002303,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1836,11),line_char(1836,22))). -user:metta_file_buffer(65,701002303,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1836,2),line_char(1836,23))). -user:metta_file_buffer(64,701002303,metta_other,['@doc','import!',['@desc',"Imports module using its relative path (second argument) and binds it to the token (first argument) which will represent imported atomspace. If first argument is &self then everything will be imported to current atomspace. The source is imported only the first time import! is called. Can load Python code (.py) or MeTTa (.metta); if ambiguous, assumes Python."],['@params',[['@param',"Symbol, which is turned into the token for accessing the imported module"],['@param',"Module name"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1831,0),line_char(1836,24))). -user:metta_file_buffer(65,702002304,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1838,1),line_char(1838,2))). -user:metta_file_buffer(65,702002304,constant,'import!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1838,3),line_char(1838,10))). -user:metta_file_buffer(66,702002305,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1838,12),line_char(1838,14))). -user:metta_file_buffer(66,702002305,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1838,15),line_char(1838,19))). -user:metta_file_buffer(66,702002305,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1838,20),line_char(1838,24))). -user:metta_file_buffer(67,702002306,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1838,26),line_char(1838,28))). -user:metta_file_buffer(66,702002306,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1838,25),line_char(1838,29))). -user:metta_file_buffer(65,702002306,metta_other,[->,'Atom','Atom',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1838,11),line_char(1838,30))). -user:metta_file_buffer(64,702002306,metta_typedecl,[:,'import!',[->,'Atom','Atom',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1838,0),line_char(1838,31))). -user:metta_file_buffer(65,703002307,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1840,1),line_char(1840,3))). -user:metta_file_buffer(65,703002307,constant,include,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1840,4),line_char(1840,11))). -user:metta_file_buffer(65,703002307,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1840,12),line_char(1840,17))). -user:metta_file_buffer(64,703002307,metta_other,[iz,include,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1840,0),line_char(1840,18))). -user:metta_file_buffer(65,704002308,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1841,1),line_char(1841,5))). -user:metta_file_buffer(65,704002308,constant,include,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1841,6),line_char(1841,13))). -user:metta_file_buffer(66,704002309,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1842,3),line_char(1842,8))). -user:metta_file_buffer(66,704002309,string,"Works just like include! but with &self as a first argument. So everything from input file will be included in the current atomspace and evaluated",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1842,9),line_char(1842,157))). -user:metta_file_buffer(65,704002309,metta_other,['@desc',"Works just like include! but with &self as a first argument. So everything from input file will be included in the current atomspace and evaluated"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1842,2),line_char(1842,158))). -user:metta_file_buffer(66,704002310,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1843,3),line_char(1843,10))). -user:metta_file_buffer(68,704002312,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1844,5),line_char(1844,11))). -user:metta_file_buffer(68,704002312,string,"Name of metta script to import",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1844,12),line_char(1844,44))). -user:metta_file_buffer(67,704002312,metta_other,['@param',"Name of metta script to import"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1844,4),line_char(1844,45))). -user:metta_file_buffer(66,704002312,array,[['@param',"Name of metta script to import"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1843,11),line_char(1844,46))). -user:metta_file_buffer(65,704002312,metta_other,['@params',[['@param',"Name of metta script to import"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1843,2),line_char(1844,47))). -user:metta_file_buffer(66,704002313,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1845,3),line_char(1845,10))). -user:metta_file_buffer(66,704002313,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1845,11),line_char(1845,22))). -user:metta_file_buffer(65,704002313,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1845,2),line_char(1845,23))). -user:metta_file_buffer(64,704002313,metta_other,['@doc',include,['@desc',"Works just like include! but with &self as a first argument. So everything from input file will be included in the current atomspace and evaluated"],['@params',[['@param',"Name of metta script to import"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1841,0),line_char(1845,24))). -user:metta_file_buffer(65,705002314,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1846,1),line_char(1846,2))). -user:metta_file_buffer(65,705002314,constant,include,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1846,3),line_char(1846,10))). -user:metta_file_buffer(66,705002315,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1846,12),line_char(1846,14))). -user:metta_file_buffer(66,705002315,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1846,15),line_char(1846,19))). -user:metta_file_buffer(66,705002315,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1846,20),line_char(1846,24))). -user:metta_file_buffer(65,705002315,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1846,11),line_char(1846,25))). -user:metta_file_buffer(64,705002315,metta_typedecl,[:,include,[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1846,0),line_char(1846,26))). -user:metta_file_buffer(65,706002316,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1849,1),line_char(1849,3))). -user:metta_file_buffer(65,706002316,constant,'include!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1849,4),line_char(1849,12))). -user:metta_file_buffer(65,706002316,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1849,13),line_char(1849,18))). -user:metta_file_buffer(64,706002316,metta_other,[iz,'include!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1849,0),line_char(1849,19))). -user:metta_file_buffer(65,707002317,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1850,1),line_char(1850,5))). -user:metta_file_buffer(65,707002317,constant,'include!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1850,6),line_char(1850,14))). -user:metta_file_buffer(66,707002318,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1851,3),line_char(1851,8))). -user:metta_file_buffer(66,707002318,string,"Everything from input file will be included in the current atomspace and evaluated, as if it were being evaluated at the REPL. Unlike import!, the source is evaluated every time include! is called.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1851,9),line_char(1851,208))). -user:metta_file_buffer(65,707002318,metta_other,['@desc',"Everything from input file will be included in the current atomspace and evaluated, as if it were being evaluated at the REPL. Unlike import!, the source is evaluated every time include! is called."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1851,2),line_char(1851,209))). -user:metta_file_buffer(66,707002319,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1852,3),line_char(1852,10))). -user:metta_file_buffer(68,707002321,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1853,5),line_char(1853,11))). -user:metta_file_buffer(68,707002321,string,"Space",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1853,12),line_char(1853,19))). -user:metta_file_buffer(67,707002321,metta_other,['@param',"Space"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1853,4),line_char(1853,20))). -user:metta_file_buffer(68,707002322,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1854,5),line_char(1854,11))). -user:metta_file_buffer(68,707002322,string,"Filename",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1854,12),line_char(1854,22))). -user:metta_file_buffer(67,707002322,metta_other,['@param',"Filename"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1854,4),line_char(1854,23))). -user:metta_file_buffer(66,707002322,array,[['@param',"Space"],['@param',"Filename"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1852,11),line_char(1854,24))). -user:metta_file_buffer(65,707002322,metta_other,['@params',[['@param',"Space"],['@param',"Filename"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1852,2),line_char(1854,25))). -user:metta_file_buffer(66,707002323,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1855,3),line_char(1855,10))). -user:metta_file_buffer(66,707002323,string,"Expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1855,11),line_char(1855,23))). -user:metta_file_buffer(65,707002323,metta_other,['@return',"Expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1855,2),line_char(1855,24))). -user:metta_file_buffer(64,707002323,metta_other,['@doc','include!',['@desc',"Everything from input file will be included in the current atomspace and evaluated, as if it were being evaluated at the REPL. Unlike import!, the source is evaluated every time include! is called."],['@params',[['@param',"Space"],['@param',"Filename"]]],['@return',"Expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1850,0),line_char(1855,25))). -user:metta_file_buffer(65,708002324,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1856,1),line_char(1856,2))). -user:metta_file_buffer(65,708002324,constant,'include!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1856,3),line_char(1856,11))). -user:metta_file_buffer(66,708002325,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1856,13),line_char(1856,15))). -user:metta_file_buffer(66,708002325,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1856,16),line_char(1856,40))). -user:metta_file_buffer(66,708002325,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1856,41),line_char(1856,47))). -user:metta_file_buffer(66,708002325,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1856,48),line_char(1856,58))). -user:metta_file_buffer(65,708002325,metta_other,[->,'hyperon::space::DynSpace','String','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1856,12),line_char(1856,59))). -user:metta_file_buffer(64,708002325,metta_typedecl,[:,'include!',[->,'hyperon::space::DynSpace','String','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1856,0),line_char(1856,60))). -user:metta_file_buffer(65,709002326,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1858,1),line_char(1858,3))). -user:metta_file_buffer(65,709002326,constant,'bind!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1858,4),line_char(1858,9))). -user:metta_file_buffer(65,709002326,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1858,10),line_char(1858,15))). -user:metta_file_buffer(64,709002326,metta_other,[iz,'bind!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1858,0),line_char(1858,16))). -user:metta_file_buffer(65,710002327,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1859,1),line_char(1859,5))). -user:metta_file_buffer(65,710002327,constant,'bind!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1859,6),line_char(1859,11))). -user:metta_file_buffer(66,710002328,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1860,3),line_char(1860,8))). -user:metta_file_buffer(66,710002328,string,"Registers a new token which is replaced with an atom during the parsing of the rest of the program",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1860,9),line_char(1860,109))). -user:metta_file_buffer(65,710002328,metta_other,['@desc',"Registers a new token which is replaced with an atom during the parsing of the rest of the program"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1860,2),line_char(1860,110))). -user:metta_file_buffer(66,710002329,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1861,3),line_char(1861,10))). -user:metta_file_buffer(68,710002331,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1862,5),line_char(1862,11))). -user:metta_file_buffer(68,710002331,string,"Token name",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1862,12),line_char(1862,24))). -user:metta_file_buffer(67,710002331,metta_other,['@param',"Token name"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1862,4),line_char(1862,25))). -user:metta_file_buffer(68,710002332,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1863,5),line_char(1863,11))). -user:metta_file_buffer(68,710002332,string,"Atom, which is associated with the token after reduction",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1863,12),line_char(1863,70))). -user:metta_file_buffer(67,710002332,metta_other,['@param',"Atom, which is associated with the token after reduction"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1863,4),line_char(1863,71))). -user:metta_file_buffer(66,710002332,array,[['@param',"Token name"],['@param',"Atom, which is associated with the token after reduction"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1861,11),line_char(1863,72))). -user:metta_file_buffer(65,710002332,metta_other,['@params',[['@param',"Token name"],['@param',"Atom, which is associated with the token after reduction"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1861,2),line_char(1863,73))). -user:metta_file_buffer(66,710002333,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1864,3),line_char(1864,10))). -user:metta_file_buffer(66,710002333,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1864,11),line_char(1864,22))). -user:metta_file_buffer(65,710002333,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1864,2),line_char(1864,23))). -user:metta_file_buffer(64,710002333,metta_other,['@doc','bind!',['@desc',"Registers a new token which is replaced with an atom during the parsing of the rest of the program"],['@params',[['@param',"Token name"],['@param',"Atom, which is associated with the token after reduction"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1859,0),line_char(1864,24))). -user:metta_file_buffer(65,711002334,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1865,1),line_char(1865,2))). -user:metta_file_buffer(65,711002334,constant,'bind!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1865,3),line_char(1865,8))). -user:metta_file_buffer(66,711002335,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1865,10),line_char(1865,12))). -user:metta_file_buffer(66,711002335,constant,'Symbol',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1865,13),line_char(1865,19))). -user:metta_file_buffer(66,711002335,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1865,20),line_char(1865,31))). -user:metta_file_buffer(67,711002336,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1865,33),line_char(1865,35))). -user:metta_file_buffer(66,711002336,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1865,32),line_char(1865,36))). -user:metta_file_buffer(65,711002336,metta_other,[->,'Symbol','%Undefined%',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1865,9),line_char(1865,37))). -user:metta_file_buffer(64,711002336,metta_typedecl,[:,'bind!',[->,'Symbol','%Undefined%',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1865,0),line_char(1865,38))). -user:metta_file_buffer(65,712002337,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1868,1),line_char(1868,3))). -user:metta_file_buffer(65,712002337,constant,'trace!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1868,4),line_char(1868,10))). -user:metta_file_buffer(65,712002337,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1868,11),line_char(1868,16))). -user:metta_file_buffer(64,712002337,metta_other,[iz,'trace!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1868,0),line_char(1868,17))). -user:metta_file_buffer(65,713002338,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1869,1),line_char(1869,5))). -user:metta_file_buffer(65,713002338,constant,'trace!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1869,6),line_char(1869,12))). -user:metta_file_buffer(66,713002339,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1870,3),line_char(1870,8))). -user:metta_file_buffer(66,713002339,string,"Prints its first argument and returns second. Both arguments will be evaluated before processing",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1870,9),line_char(1870,107))). -user:metta_file_buffer(65,713002339,metta_other,['@desc',"Prints its first argument and returns second. Both arguments will be evaluated before processing"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1870,2),line_char(1870,108))). -user:metta_file_buffer(66,713002340,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1871,3),line_char(1871,10))). -user:metta_file_buffer(68,713002342,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1872,5),line_char(1872,11))). -user:metta_file_buffer(68,713002342,string,"Atom to print",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1872,12),line_char(1872,27))). -user:metta_file_buffer(67,713002342,metta_other,['@param',"Atom to print"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1872,4),line_char(1872,28))). -user:metta_file_buffer(68,713002343,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1873,5),line_char(1873,11))). -user:metta_file_buffer(68,713002343,string,"Atom to return",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1873,12),line_char(1873,28))). -user:metta_file_buffer(67,713002343,metta_other,['@param',"Atom to return"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1873,4),line_char(1873,29))). -user:metta_file_buffer(66,713002343,array,[['@param',"Atom to print"],['@param',"Atom to return"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1871,11),line_char(1873,30))). -user:metta_file_buffer(65,713002343,metta_other,['@params',[['@param',"Atom to print"],['@param',"Atom to return"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1871,2),line_char(1873,31))). -user:metta_file_buffer(66,713002344,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1874,3),line_char(1874,10))). -user:metta_file_buffer(66,713002344,string,"Evaluated second input",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1874,11),line_char(1874,35))). -user:metta_file_buffer(65,713002344,metta_other,['@return',"Evaluated second input"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1874,2),line_char(1874,36))). -user:metta_file_buffer(64,713002344,metta_other,['@doc','trace!',['@desc',"Prints its first argument and returns second. Both arguments will be evaluated before processing"],['@params',[['@param',"Atom to print"],['@param',"Atom to return"]]],['@return',"Evaluated second input"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1869,0),line_char(1874,37))). -user:metta_file_buffer(65,714002345,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1875,1),line_char(1875,2))). -user:metta_file_buffer(65,714002345,constant,'trace!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1875,3),line_char(1875,9))). -user:metta_file_buffer(66,714002346,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1875,11),line_char(1875,13))). -user:metta_file_buffer(66,714002346,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1875,14),line_char(1875,25))). -user:metta_file_buffer(66,714002346,variable,_645600,['_a'=_645600],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1875,26),line_char(1875,28))). -user:metta_file_buffer(66,714002346,variable,_646844,['_a'=_646844],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1875,29),line_char(1875,31))). -user:metta_file_buffer(65,714002346,indexed(metta_other,[->,'%Undefined%',_647698,_647698]),[->,'%Undefined%',_647774,_647774],['_a'=_647774],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1875,10),line_char(1875,32))). -user:metta_file_buffer(64,714002346,indexed(metta_typedecl,[:,'trace!',[->,'%Undefined%',_648340,_648340]]),[:,'trace!',[->,'%Undefined%',_648434,_648434]],['_a'=_648434],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1875,0),line_char(1875,33))). -user:metta_file_buffer(65,715002347,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1878,1),line_char(1878,3))). -user:metta_file_buffer(65,715002347,constant,'println!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1878,4),line_char(1878,12))). -user:metta_file_buffer(65,715002347,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1878,13),line_char(1878,18))). -user:metta_file_buffer(64,715002347,metta_other,[iz,'println!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1878,0),line_char(1878,19))). -user:metta_file_buffer(65,716002348,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1879,1),line_char(1879,5))). -user:metta_file_buffer(65,716002348,constant,'println!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1879,6),line_char(1879,14))). -user:metta_file_buffer(66,716002349,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1880,3),line_char(1880,8))). -user:metta_file_buffer(66,716002349,string,"Prints a line of text to the console",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1880,9),line_char(1880,47))). -user:metta_file_buffer(65,716002349,metta_other,['@desc',"Prints a line of text to the console"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1880,2),line_char(1880,48))). -user:metta_file_buffer(66,716002350,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1881,3),line_char(1881,10))). -user:metta_file_buffer(68,716002352,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1882,5),line_char(1882,11))). -user:metta_file_buffer(68,716002352,string,"Expression/atom to be printed out",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1882,12),line_char(1882,47))). -user:metta_file_buffer(67,716002352,metta_other,['@param',"Expression/atom to be printed out"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1882,4),line_char(1882,48))). -user:metta_file_buffer(66,716002352,array,[['@param',"Expression/atom to be printed out"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1881,11),line_char(1882,49))). -user:metta_file_buffer(65,716002352,metta_other,['@params',[['@param',"Expression/atom to be printed out"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1881,2),line_char(1882,50))). -user:metta_file_buffer(66,716002353,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1883,3),line_char(1883,10))). -user:metta_file_buffer(66,716002353,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1883,11),line_char(1883,22))). -user:metta_file_buffer(65,716002353,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1883,2),line_char(1883,23))). -user:metta_file_buffer(64,716002353,metta_other,['@doc','println!',['@desc',"Prints a line of text to the console"],['@params',[['@param',"Expression/atom to be printed out"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1879,0),line_char(1883,24))). -user:metta_file_buffer(65,717002354,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1884,1),line_char(1884,2))). -user:metta_file_buffer(65,717002354,constant,'println!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1884,3),line_char(1884,11))). -user:metta_file_buffer(66,717002355,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1884,13),line_char(1884,15))). -user:metta_file_buffer(66,717002355,constant,'%Undefined%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1884,16),line_char(1884,27))). -user:metta_file_buffer(67,717002356,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1884,29),line_char(1884,31))). -user:metta_file_buffer(66,717002356,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1884,28),line_char(1884,32))). -user:metta_file_buffer(65,717002356,metta_other,[->,'%Undefined%',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1884,12),line_char(1884,33))). -user:metta_file_buffer(64,717002356,metta_typedecl,[:,'println!',[->,'%Undefined%',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1884,0),line_char(1884,34))). -user:metta_file_buffer(65,718002357,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1887,1),line_char(1887,3))). -user:metta_file_buffer(65,718002357,constant,'format-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1887,4),line_char(1887,15))). -user:metta_file_buffer(65,718002357,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1887,16),line_char(1887,21))). -user:metta_file_buffer(64,718002357,metta_other,[iz,'format-args','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1887,0),line_char(1887,22))). -user:metta_file_buffer(65,719002358,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1888,1),line_char(1888,5))). -user:metta_file_buffer(65,719002358,constant,'format-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1888,6),line_char(1888,17))). -user:metta_file_buffer(66,719002359,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1889,3),line_char(1889,8))). -user:metta_file_buffer(66,719002359,string,"Fills {} symbols in the input expression with atoms from the second expression. E.g. (format-args (Probability of {} is {}%) (head 50)) gives [(Probability of head is 50%)]. Atoms in the second input value could be variables",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1889,9),line_char(1889,235))). -user:metta_file_buffer(65,719002359,metta_other,['@desc',"Fills {} symbols in the input expression with atoms from the second expression. E.g. (format-args (Probability of {} is {}%) (head 50)) gives [(Probability of head is 50%)]. Atoms in the second input value could be variables"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1889,2),line_char(1889,236))). -user:metta_file_buffer(66,719002360,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1890,3),line_char(1890,10))). -user:metta_file_buffer(68,719002362,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1891,5),line_char(1891,11))). -user:metta_file_buffer(68,719002362,string,"Expression with {} symbols to be replaced",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1891,12),line_char(1891,55))). -user:metta_file_buffer(67,719002362,metta_other,['@param',"Expression with {} symbols to be replaced"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1891,4),line_char(1891,56))). -user:metta_file_buffer(68,719002363,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1892,5),line_char(1892,11))). -user:metta_file_buffer(68,719002363,string,"Atoms to be placed inside expression instead of {}",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1892,12),line_char(1892,64))). -user:metta_file_buffer(67,719002363,metta_other,['@param',"Atoms to be placed inside expression instead of {}"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1892,4),line_char(1892,65))). -user:metta_file_buffer(66,719002363,array,[['@param',"Expression with {} symbols to be replaced"],['@param',"Atoms to be placed inside expression instead of {}"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1890,11),line_char(1892,66))). -user:metta_file_buffer(65,719002363,metta_other,['@params',[['@param',"Expression with {} symbols to be replaced"],['@param',"Atoms to be placed inside expression instead of {}"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1890,2),line_char(1892,67))). -user:metta_file_buffer(66,719002364,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1893,3),line_char(1893,10))). -user:metta_file_buffer(66,719002364,string,"Expression with replaced {} with atoms",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1893,11),line_char(1893,51))). -user:metta_file_buffer(65,719002364,metta_other,['@return',"Expression with replaced {} with atoms"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1893,2),line_char(1893,52))). -user:metta_file_buffer(64,719002364,metta_other,['@doc','format-args',['@desc',"Fills {} symbols in the input expression with atoms from the second expression. E.g. (format-args (Probability of {} is {}%) (head 50)) gives [(Probability of head is 50%)]. Atoms in the second input value could be variables"],['@params',[['@param',"Expression with {} symbols to be replaced"],['@param',"Atoms to be placed inside expression instead of {}"]]],['@return',"Expression with replaced {} with atoms"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1888,0),line_char(1893,53))). -user:metta_file_buffer(65,720002365,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1894,1),line_char(1894,2))). -user:metta_file_buffer(65,720002365,constant,'format-args',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1894,3),line_char(1894,14))). -user:metta_file_buffer(66,720002366,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1894,16),line_char(1894,18))). -user:metta_file_buffer(66,720002366,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1894,19),line_char(1894,25))). -user:metta_file_buffer(66,720002366,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1894,26),line_char(1894,30))). -user:metta_file_buffer(66,720002366,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1894,31),line_char(1894,37))). -user:metta_file_buffer(65,720002366,metta_other,[->,'String','Atom','String'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1894,15),line_char(1894,38))). -user:metta_file_buffer(64,720002366,metta_typedecl,[:,'format-args',[->,'String','Atom','String']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1894,0),line_char(1894,39))). -user:metta_file_buffer(65,721002367,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1897,1),line_char(1897,3))). -user:metta_file_buffer(65,721002367,constant,sealed,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1897,4),line_char(1897,10))). -user:metta_file_buffer(65,721002367,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1897,11),line_char(1897,16))). -user:metta_file_buffer(64,721002367,metta_other,[iz,sealed,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1897,0),line_char(1897,17))). -user:metta_file_buffer(65,722002368,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1898,1),line_char(1898,5))). -user:metta_file_buffer(65,722002368,constant,sealed,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1898,6),line_char(1898,12))). -user:metta_file_buffer(66,722002369,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1899,3),line_char(1899,8))). -user:metta_file_buffer(66,722002369,string,"Replaces all occurrences of any var from var list (first argument) inside atom (second argument) by unique variable. Can be used to create a locally scoped variables",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1899,9),line_char(1899,176))). -user:metta_file_buffer(65,722002369,metta_other,['@desc',"Replaces all occurrences of any var from var list (first argument) inside atom (second argument) by unique variable. Can be used to create a locally scoped variables"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1899,2),line_char(1899,177))). -user:metta_file_buffer(66,722002370,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1900,3),line_char(1900,10))). -user:metta_file_buffer(68,722002372,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1901,9),line_char(1901,15))). -user:metta_file_buffer(68,722002372,string,"Variable list e.g. ($x $y)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1901,16),line_char(1901,44))). -user:metta_file_buffer(67,722002372,metta_other,['@param',"Variable list e.g. ($x $y)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1901,8),line_char(1901,45))). -user:metta_file_buffer(68,722002373,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1902,9),line_char(1902,15))). -user:metta_file_buffer(68,722002373,string,"Atom which uses those variables",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1902,16),line_char(1902,49))). -user:metta_file_buffer(67,722002373,metta_other,['@param',"Atom which uses those variables"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1902,8),line_char(1902,50))). -user:metta_file_buffer(66,722002373,array,[['@param',"Variable list e.g. ($x $y)"],['@param',"Atom which uses those variables"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1900,11),line_char(1902,51))). -user:metta_file_buffer(65,722002373,metta_other,['@params',[['@param',"Variable list e.g. ($x $y)"],['@param',"Atom which uses those variables"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1900,2),line_char(1902,52))). -user:metta_file_buffer(66,722002374,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1903,3),line_char(1903,10))). -user:metta_file_buffer(66,722002374,string,"Second argument but with variables being replaced with unique variables",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1903,11),line_char(1903,84))). -user:metta_file_buffer(65,722002374,metta_other,['@return',"Second argument but with variables being replaced with unique variables"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1903,2),line_char(1903,85))). -user:metta_file_buffer(64,722002374,metta_other,['@doc',sealed,['@desc',"Replaces all occurrences of any var from var list (first argument) inside atom (second argument) by unique variable. Can be used to create a locally scoped variables"],['@params',[['@param',"Variable list e.g. ($x $y)"],['@param',"Atom which uses those variables"]]],['@return',"Second argument but with variables being replaced with unique variables"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1898,0),line_char(1903,86))). -user:metta_file_buffer(65,723002375,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1904,1),line_char(1904,2))). -user:metta_file_buffer(65,723002375,constant,sealed,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1904,3),line_char(1904,9))). -user:metta_file_buffer(66,723002376,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1904,11),line_char(1904,13))). -user:metta_file_buffer(66,723002376,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1904,14),line_char(1904,24))). -user:metta_file_buffer(66,723002376,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1904,25),line_char(1904,29))). -user:metta_file_buffer(66,723002376,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1904,30),line_char(1904,34))). -user:metta_file_buffer(65,723002376,metta_other,[->,'Expression','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1904,10),line_char(1904,35))). -user:metta_file_buffer(64,723002376,metta_typedecl,[:,sealed,[->,'Expression','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1904,0),line_char(1904,36))). -user:metta_file_buffer(65,724002377,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1906,1),line_char(1906,3))). -user:metta_file_buffer(65,724002377,constant,'&self',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1906,4),line_char(1906,9))). -user:metta_file_buffer(65,724002377,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1906,10),line_char(1906,15))). -user:metta_file_buffer(64,724002377,metta_other,[iz,'&self','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1906,0),line_char(1906,16))). -user:metta_file_buffer(65,725002378,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1908,1),line_char(1908,5))). -user:metta_file_buffer(65,725002378,constant,'&self',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1908,6),line_char(1908,11))). -user:metta_file_buffer(66,725002379,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1909,3),line_char(1909,8))). -user:metta_file_buffer(66,725002379,string,"Returns reference to the current atomspace",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1909,9),line_char(1909,53))). -user:metta_file_buffer(65,725002379,metta_other,['@desc',"Returns reference to the current atomspace"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1909,2),line_char(1909,54))). -user:metta_file_buffer(66,725002380,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1910,3),line_char(1910,10))). -user:metta_file_buffer(66,725002381,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1910,11),line_char(1910,13))). -user:metta_file_buffer(65,725002381,metta_other,['@params',[]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1910,2),line_char(1910,14))). -user:metta_file_buffer(66,725002382,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1911,3),line_char(1911,10))). -user:metta_file_buffer(66,725002382,string,"Reference to the current atomspace",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1911,11),line_char(1911,47))). -user:metta_file_buffer(65,725002382,metta_other,['@return',"Reference to the current atomspace"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1911,2),line_char(1911,48))). -user:metta_file_buffer(64,725002382,metta_other,['@doc','&self',['@desc',"Returns reference to the current atomspace"],['@params',[]],['@return',"Reference to the current atomspace"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1908,0),line_char(1911,49))). -user:metta_file_buffer(64,726002382,indexed(metta_comment,"; TODO: help! not working for operations which are defined in both Python and"),'$COMMENT'("; TODO: help! not working for operations which are defined in both Python and",1913,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1913,0),line_char(1913,77))). -user:metta_file_buffer(64,726002382,indexed(metta_comment,"; Rust standard library: +, -, *, /, %, <, >, <=, >=, =="),'$COMMENT'("; Rust standard library: +, -, *, /, %, <, >, <=, >=, ==",1914,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1914,0),line_char(1914,56))). -user:metta_file_buffer(65,726002383,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1916,1),line_char(1916,3))). -user:metta_file_buffer(65,726002383,constant,+,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1916,4),line_char(1916,5))). -user:metta_file_buffer(65,726002383,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1916,6),line_char(1916,11))). -user:metta_file_buffer(64,726002383,metta_other,[iz,+,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1916,0),line_char(1916,12))). -user:metta_file_buffer(65,727002384,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1917,1),line_char(1917,5))). -user:metta_file_buffer(65,727002384,constant,+,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1917,6),line_char(1917,7))). -user:metta_file_buffer(66,727002385,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1918,3),line_char(1918,8))). -user:metta_file_buffer(66,727002385,string,"Sums two numbers",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1918,9),line_char(1918,27))). -user:metta_file_buffer(65,727002385,metta_other,['@desc',"Sums two numbers"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1918,2),line_char(1918,28))). -user:metta_file_buffer(66,727002386,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1919,3),line_char(1919,10))). -user:metta_file_buffer(68,727002388,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1920,5),line_char(1920,11))). -user:metta_file_buffer(68,727002388,string,"Addend",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1920,12),line_char(1920,20))). -user:metta_file_buffer(67,727002388,metta_other,['@param',"Addend"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1920,4),line_char(1920,21))). -user:metta_file_buffer(68,727002389,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1921,5),line_char(1921,11))). -user:metta_file_buffer(68,727002389,string,"Augend",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1921,12),line_char(1921,20))). -user:metta_file_buffer(67,727002389,metta_other,['@param',"Augend"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1921,4),line_char(1921,21))). -user:metta_file_buffer(66,727002389,array,[['@param',"Addend"],['@param',"Augend"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1919,11),line_char(1921,22))). -user:metta_file_buffer(65,727002389,metta_other,['@params',[['@param',"Addend"],['@param',"Augend"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1919,2),line_char(1921,23))). -user:metta_file_buffer(66,727002390,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1922,3),line_char(1922,10))). -user:metta_file_buffer(66,727002390,string,"Sum",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1922,11),line_char(1922,16))). -user:metta_file_buffer(65,727002390,metta_other,['@return',"Sum"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1922,2),line_char(1922,17))). -user:metta_file_buffer(64,727002390,metta_other,['@doc',+,['@desc',"Sums two numbers"],['@params',[['@param',"Addend"],['@param',"Augend"]]],['@return',"Sum"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1917,0),line_char(1922,18))). -user:metta_file_buffer(65,728002391,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1923,1),line_char(1923,2))). -user:metta_file_buffer(65,728002391,constant,+,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1923,3),line_char(1923,4))). -user:metta_file_buffer(66,728002392,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1923,6),line_char(1923,8))). -user:metta_file_buffer(66,728002392,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1923,9),line_char(1923,15))). -user:metta_file_buffer(66,728002392,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1923,16),line_char(1923,22))). -user:metta_file_buffer(66,728002392,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1923,23),line_char(1923,29))). -user:metta_file_buffer(65,728002392,metta_other,[->,'Number','Number','Number'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1923,5),line_char(1923,30))). -user:metta_file_buffer(64,728002392,metta_typedecl,[:,+,[->,'Number','Number','Number']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1923,0),line_char(1923,31))). -user:metta_file_buffer(65,729002393,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1926,1),line_char(1926,3))). -user:metta_file_buffer(65,729002393,constant,-,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1926,4),line_char(1926,5))). -user:metta_file_buffer(65,729002393,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1926,6),line_char(1926,11))). -user:metta_file_buffer(64,729002393,metta_other,[iz,-,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1926,0),line_char(1926,12))). -user:metta_file_buffer(65,730002394,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1927,1),line_char(1927,5))). -user:metta_file_buffer(65,730002394,constant,-,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1927,6),line_char(1927,7))). -user:metta_file_buffer(66,730002395,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1928,3),line_char(1928,8))). -user:metta_file_buffer(66,730002395,string,"Subtracts second argument from first one",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1928,9),line_char(1928,51))). -user:metta_file_buffer(65,730002395,metta_other,['@desc',"Subtracts second argument from first one"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1928,2),line_char(1928,52))). -user:metta_file_buffer(66,730002396,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1929,3),line_char(1929,10))). -user:metta_file_buffer(68,730002398,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1930,5),line_char(1930,11))). -user:metta_file_buffer(68,730002398,string,"Minuend",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1930,12),line_char(1930,21))). -user:metta_file_buffer(67,730002398,metta_other,['@param',"Minuend"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1930,4),line_char(1930,22))). -user:metta_file_buffer(68,730002399,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1931,5),line_char(1931,11))). -user:metta_file_buffer(68,730002399,string,"Deductible",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1931,12),line_char(1931,24))). -user:metta_file_buffer(67,730002399,metta_other,['@param',"Deductible"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1931,4),line_char(1931,25))). -user:metta_file_buffer(66,730002399,array,[['@param',"Minuend"],['@param',"Deductible"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1929,11),line_char(1931,26))). -user:metta_file_buffer(65,730002399,metta_other,['@params',[['@param',"Minuend"],['@param',"Deductible"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1929,2),line_char(1931,27))). -user:metta_file_buffer(66,730002400,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1932,3),line_char(1932,10))). -user:metta_file_buffer(66,730002400,string,"Difference",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1932,11),line_char(1932,23))). -user:metta_file_buffer(65,730002400,metta_other,['@return',"Difference"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1932,2),line_char(1932,24))). -user:metta_file_buffer(64,730002400,metta_other,['@doc',-,['@desc',"Subtracts second argument from first one"],['@params',[['@param',"Minuend"],['@param',"Deductible"]]],['@return',"Difference"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1927,0),line_char(1932,25))). -user:metta_file_buffer(65,731002401,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1933,1),line_char(1933,2))). -user:metta_file_buffer(65,731002401,constant,-,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1933,3),line_char(1933,4))). -user:metta_file_buffer(66,731002402,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1933,6),line_char(1933,8))). -user:metta_file_buffer(66,731002402,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1933,9),line_char(1933,15))). -user:metta_file_buffer(66,731002402,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1933,16),line_char(1933,22))). -user:metta_file_buffer(66,731002402,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1933,23),line_char(1933,29))). -user:metta_file_buffer(65,731002402,metta_other,[->,'Number','Number','Number'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1933,5),line_char(1933,30))). -user:metta_file_buffer(64,731002402,metta_typedecl,[:,-,[->,'Number','Number','Number']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1933,0),line_char(1933,31))). -user:metta_file_buffer(65,732002403,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1936,1),line_char(1936,3))). -user:metta_file_buffer(65,732002403,constant,*,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1936,4),line_char(1936,5))). -user:metta_file_buffer(65,732002403,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1936,6),line_char(1936,11))). -user:metta_file_buffer(64,732002403,metta_other,[iz,*,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1936,0),line_char(1936,12))). -user:metta_file_buffer(65,733002404,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1937,1),line_char(1937,5))). -user:metta_file_buffer(65,733002404,constant,*,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1937,6),line_char(1937,7))). -user:metta_file_buffer(66,733002405,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1938,3),line_char(1938,8))). -user:metta_file_buffer(66,733002405,string,"Multiplies two numbers",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1938,9),line_char(1938,33))). -user:metta_file_buffer(65,733002405,metta_other,['@desc',"Multiplies two numbers"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1938,2),line_char(1938,34))). -user:metta_file_buffer(66,733002406,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1939,3),line_char(1939,10))). -user:metta_file_buffer(68,733002408,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1940,5),line_char(1940,11))). -user:metta_file_buffer(68,733002408,string,"Multiplier",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1940,12),line_char(1940,24))). -user:metta_file_buffer(67,733002408,metta_other,['@param',"Multiplier"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1940,4),line_char(1940,25))). -user:metta_file_buffer(68,733002409,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1941,5),line_char(1941,11))). -user:metta_file_buffer(68,733002409,string,"Multiplicand",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1941,12),line_char(1941,26))). -user:metta_file_buffer(67,733002409,metta_other,['@param',"Multiplicand"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1941,4),line_char(1941,27))). -user:metta_file_buffer(66,733002409,array,[['@param',"Multiplier"],['@param',"Multiplicand"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1939,11),line_char(1941,28))). -user:metta_file_buffer(65,733002409,metta_other,['@params',[['@param',"Multiplier"],['@param',"Multiplicand"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1939,2),line_char(1941,29))). -user:metta_file_buffer(66,733002410,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1942,3),line_char(1942,10))). -user:metta_file_buffer(66,733002410,string,"Product",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1942,11),line_char(1942,20))). -user:metta_file_buffer(65,733002410,metta_other,['@return',"Product"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1942,2),line_char(1942,21))). -user:metta_file_buffer(64,733002410,metta_other,['@doc',*,['@desc',"Multiplies two numbers"],['@params',[['@param',"Multiplier"],['@param',"Multiplicand"]]],['@return',"Product"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1937,0),line_char(1942,22))). -user:metta_file_buffer(65,734002411,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1943,1),line_char(1943,2))). -user:metta_file_buffer(65,734002411,constant,*,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1943,3),line_char(1943,4))). -user:metta_file_buffer(66,734002412,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1943,6),line_char(1943,8))). -user:metta_file_buffer(66,734002412,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1943,9),line_char(1943,15))). -user:metta_file_buffer(66,734002412,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1943,16),line_char(1943,22))). -user:metta_file_buffer(66,734002412,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1943,23),line_char(1943,29))). -user:metta_file_buffer(65,734002412,metta_other,[->,'Number','Number','Number'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1943,5),line_char(1943,30))). -user:metta_file_buffer(64,734002412,metta_typedecl,[:,*,[->,'Number','Number','Number']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1943,0),line_char(1943,31))). -user:metta_file_buffer(65,735002413,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1946,1),line_char(1946,3))). -user:metta_file_buffer(65,735002413,constant,/,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1946,4),line_char(1946,5))). -user:metta_file_buffer(65,735002413,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1946,6),line_char(1946,11))). -user:metta_file_buffer(64,735002413,metta_other,[iz,/,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1946,0),line_char(1946,12))). -user:metta_file_buffer(65,736002414,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1947,1),line_char(1947,5))). -user:metta_file_buffer(65,736002414,constant,/,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1947,6),line_char(1947,7))). -user:metta_file_buffer(66,736002415,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1948,3),line_char(1948,8))). -user:metta_file_buffer(66,736002415,string,"Divides first argument by second one",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1948,9),line_char(1948,47))). -user:metta_file_buffer(65,736002415,metta_other,['@desc',"Divides first argument by second one"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1948,2),line_char(1948,48))). -user:metta_file_buffer(66,736002416,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1949,3),line_char(1949,10))). -user:metta_file_buffer(68,736002418,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1950,5),line_char(1950,11))). -user:metta_file_buffer(68,736002418,string,"Dividend",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1950,12),line_char(1950,22))). -user:metta_file_buffer(67,736002418,metta_other,['@param',"Dividend"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1950,4),line_char(1950,23))). -user:metta_file_buffer(68,736002419,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1951,5),line_char(1951,11))). -user:metta_file_buffer(68,736002419,string,"Divisor",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1951,12),line_char(1951,21))). -user:metta_file_buffer(67,736002419,metta_other,['@param',"Divisor"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1951,4),line_char(1951,22))). -user:metta_file_buffer(66,736002419,array,[['@param',"Dividend"],['@param',"Divisor"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1949,11),line_char(1951,23))). -user:metta_file_buffer(65,736002419,metta_other,['@params',[['@param',"Dividend"],['@param',"Divisor"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1949,2),line_char(1951,24))). -user:metta_file_buffer(66,736002420,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1952,3),line_char(1952,10))). -user:metta_file_buffer(66,736002420,string,"Fraction",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1952,11),line_char(1952,21))). -user:metta_file_buffer(65,736002420,metta_other,['@return',"Fraction"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1952,2),line_char(1952,22))). -user:metta_file_buffer(64,736002420,metta_other,['@doc',/,['@desc',"Divides first argument by second one"],['@params',[['@param',"Dividend"],['@param',"Divisor"]]],['@return',"Fraction"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1947,0),line_char(1952,23))). -user:metta_file_buffer(65,737002421,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1953,1),line_char(1953,2))). -user:metta_file_buffer(65,737002421,constant,/,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1953,3),line_char(1953,4))). -user:metta_file_buffer(66,737002422,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1953,6),line_char(1953,8))). -user:metta_file_buffer(66,737002422,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1953,9),line_char(1953,15))). -user:metta_file_buffer(66,737002422,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1953,16),line_char(1953,22))). -user:metta_file_buffer(66,737002422,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1953,23),line_char(1953,29))). -user:metta_file_buffer(65,737002422,metta_other,[->,'Number','Number','Number'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1953,5),line_char(1953,30))). -user:metta_file_buffer(64,737002422,metta_typedecl,[:,/,[->,'Number','Number','Number']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1953,0),line_char(1953,31))). -user:metta_file_buffer(65,738002423,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1956,1),line_char(1956,3))). -user:metta_file_buffer(65,738002423,constant,'%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1956,4),line_char(1956,5))). -user:metta_file_buffer(65,738002423,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1956,6),line_char(1956,11))). -user:metta_file_buffer(64,738002423,metta_other,[iz,'%','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1956,0),line_char(1956,12))). -user:metta_file_buffer(65,739002424,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1957,1),line_char(1957,5))). -user:metta_file_buffer(65,739002424,constant,'%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1957,6),line_char(1957,7))). -user:metta_file_buffer(66,739002425,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1958,3),line_char(1958,8))). -user:metta_file_buffer(66,739002425,string,"Modulo operator. It returns remainder of dividing first argument by second argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1958,9),line_char(1958,94))). -user:metta_file_buffer(65,739002425,metta_other,['@desc',"Modulo operator. It returns remainder of dividing first argument by second argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1958,2),line_char(1958,95))). -user:metta_file_buffer(66,739002426,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1959,3),line_char(1959,10))). -user:metta_file_buffer(68,739002428,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1960,5),line_char(1960,11))). -user:metta_file_buffer(68,739002428,string,"Dividend",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1960,12),line_char(1960,22))). -user:metta_file_buffer(67,739002428,metta_other,['@param',"Dividend"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1960,4),line_char(1960,23))). -user:metta_file_buffer(68,739002429,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1961,5),line_char(1961,11))). -user:metta_file_buffer(68,739002429,string,"Divisor",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1961,12),line_char(1961,21))). -user:metta_file_buffer(67,739002429,metta_other,['@param',"Divisor"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1961,4),line_char(1961,22))). -user:metta_file_buffer(66,739002429,array,[['@param',"Dividend"],['@param',"Divisor"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1959,11),line_char(1961,23))). -user:metta_file_buffer(65,739002429,metta_other,['@params',[['@param',"Dividend"],['@param',"Divisor"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1959,2),line_char(1961,24))). -user:metta_file_buffer(66,739002430,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1962,3),line_char(1962,10))). -user:metta_file_buffer(66,739002430,string,"Remainder",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1962,11),line_char(1962,22))). -user:metta_file_buffer(65,739002430,metta_other,['@return',"Remainder"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1962,2),line_char(1962,23))). -user:metta_file_buffer(64,739002430,metta_other,['@doc','%',['@desc',"Modulo operator. It returns remainder of dividing first argument by second argument"],['@params',[['@param',"Dividend"],['@param',"Divisor"]]],['@return',"Remainder"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1957,0),line_char(1962,24))). -user:metta_file_buffer(65,740002431,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1963,1),line_char(1963,2))). -user:metta_file_buffer(65,740002431,constant,'%',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1963,3),line_char(1963,4))). -user:metta_file_buffer(66,740002432,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1963,6),line_char(1963,8))). -user:metta_file_buffer(66,740002432,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1963,9),line_char(1963,15))). -user:metta_file_buffer(66,740002432,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1963,16),line_char(1963,22))). -user:metta_file_buffer(66,740002432,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1963,23),line_char(1963,29))). -user:metta_file_buffer(65,740002432,metta_other,[->,'Number','Number','Number'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1963,5),line_char(1963,30))). -user:metta_file_buffer(64,740002432,metta_typedecl,[:,'%',[->,'Number','Number','Number']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1963,0),line_char(1963,31))). -user:metta_file_buffer(65,741002433,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1966,1),line_char(1966,3))). -user:metta_file_buffer(65,741002433,constant,<,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1966,4),line_char(1966,5))). -user:metta_file_buffer(65,741002433,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1966,6),line_char(1966,11))). -user:metta_file_buffer(64,741002433,metta_other,[iz,<,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1966,0),line_char(1966,12))). -user:metta_file_buffer(65,742002434,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1967,1),line_char(1967,5))). -user:metta_file_buffer(65,742002434,constant,<,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1967,6),line_char(1967,7))). -user:metta_file_buffer(66,742002435,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1968,3),line_char(1968,8))). -user:metta_file_buffer(66,742002435,string,"Less than. Checks if first argument is less than second one",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1968,9),line_char(1968,70))). -user:metta_file_buffer(65,742002435,metta_other,['@desc',"Less than. Checks if first argument is less than second one"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1968,2),line_char(1968,71))). -user:metta_file_buffer(66,742002436,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1969,3),line_char(1969,10))). -user:metta_file_buffer(68,742002438,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1970,5),line_char(1970,11))). -user:metta_file_buffer(68,742002438,string,"First number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1970,12),line_char(1970,26))). -user:metta_file_buffer(67,742002438,metta_other,['@param',"First number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1970,4),line_char(1970,27))). -user:metta_file_buffer(68,742002439,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1971,5),line_char(1971,11))). -user:metta_file_buffer(68,742002439,string,"Second number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1971,12),line_char(1971,27))). -user:metta_file_buffer(67,742002439,metta_other,['@param',"Second number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1971,4),line_char(1971,28))). -user:metta_file_buffer(66,742002439,array,[['@param',"First number"],['@param',"Second number"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1969,11),line_char(1971,29))). -user:metta_file_buffer(65,742002439,metta_other,['@params',[['@param',"First number"],['@param',"Second number"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1969,2),line_char(1971,30))). -user:metta_file_buffer(66,742002440,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1972,3),line_char(1972,10))). -user:metta_file_buffer(66,742002440,string,"True if first argument is less than second, False - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1972,11),line_char(1972,74))). -user:metta_file_buffer(65,742002440,metta_other,['@return',"True if first argument is less than second, False - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1972,2),line_char(1972,75))). -user:metta_file_buffer(64,742002440,metta_other,['@doc',<,['@desc',"Less than. Checks if first argument is less than second one"],['@params',[['@param',"First number"],['@param',"Second number"]]],['@return',"True if first argument is less than second, False - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1967,0),line_char(1972,76))). -user:metta_file_buffer(65,743002441,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1973,1),line_char(1973,2))). -user:metta_file_buffer(65,743002441,constant,<,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1973,3),line_char(1973,4))). -user:metta_file_buffer(66,743002442,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1973,6),line_char(1973,8))). -user:metta_file_buffer(66,743002442,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1973,9),line_char(1973,15))). -user:metta_file_buffer(66,743002442,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1973,16),line_char(1973,22))). -user:metta_file_buffer(66,743002442,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1973,23),line_char(1973,27))). -user:metta_file_buffer(65,743002442,metta_other,[->,'Number','Number','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1973,5),line_char(1973,28))). -user:metta_file_buffer(64,743002442,metta_typedecl,[:,<,[->,'Number','Number','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1973,0),line_char(1973,29))). -user:metta_file_buffer(65,744002443,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1976,1),line_char(1976,3))). -user:metta_file_buffer(65,744002443,constant,>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1976,4),line_char(1976,5))). -user:metta_file_buffer(65,744002443,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1976,6),line_char(1976,11))). -user:metta_file_buffer(64,744002443,metta_other,[iz,>,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1976,0),line_char(1976,12))). -user:metta_file_buffer(65,745002444,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1977,1),line_char(1977,5))). -user:metta_file_buffer(65,745002444,constant,>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1977,6),line_char(1977,7))). -user:metta_file_buffer(66,745002445,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1978,3),line_char(1978,8))). -user:metta_file_buffer(66,745002445,string,"Greater than. Checks if first argument is greater than second one",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1978,9),line_char(1978,76))). -user:metta_file_buffer(65,745002445,metta_other,['@desc',"Greater than. Checks if first argument is greater than second one"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1978,2),line_char(1978,77))). -user:metta_file_buffer(66,745002446,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1979,3),line_char(1979,10))). -user:metta_file_buffer(68,745002448,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1980,5),line_char(1980,11))). -user:metta_file_buffer(68,745002448,string,"First number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1980,12),line_char(1980,26))). -user:metta_file_buffer(67,745002448,metta_other,['@param',"First number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1980,4),line_char(1980,27))). -user:metta_file_buffer(68,745002449,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1981,5),line_char(1981,11))). -user:metta_file_buffer(68,745002449,string,"Second number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1981,12),line_char(1981,27))). -user:metta_file_buffer(67,745002449,metta_other,['@param',"Second number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1981,4),line_char(1981,28))). -user:metta_file_buffer(66,745002449,array,[['@param',"First number"],['@param',"Second number"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1979,11),line_char(1981,29))). -user:metta_file_buffer(65,745002449,metta_other,['@params',[['@param',"First number"],['@param',"Second number"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1979,2),line_char(1981,30))). -user:metta_file_buffer(66,745002450,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1982,3),line_char(1982,10))). -user:metta_file_buffer(66,745002450,string,"True if first argument is greater than second, False - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1982,11),line_char(1982,77))). -user:metta_file_buffer(65,745002450,metta_other,['@return',"True if first argument is greater than second, False - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1982,2),line_char(1982,78))). -user:metta_file_buffer(64,745002450,metta_other,['@doc',>,['@desc',"Greater than. Checks if first argument is greater than second one"],['@params',[['@param',"First number"],['@param',"Second number"]]],['@return',"True if first argument is greater than second, False - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1977,0),line_char(1982,79))). -user:metta_file_buffer(65,746002451,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1983,1),line_char(1983,2))). -user:metta_file_buffer(65,746002451,constant,>,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1983,3),line_char(1983,4))). -user:metta_file_buffer(66,746002452,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1983,6),line_char(1983,8))). -user:metta_file_buffer(66,746002452,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1983,9),line_char(1983,15))). -user:metta_file_buffer(66,746002452,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1983,16),line_char(1983,22))). -user:metta_file_buffer(66,746002452,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1983,23),line_char(1983,27))). -user:metta_file_buffer(65,746002452,metta_other,[->,'Number','Number','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1983,5),line_char(1983,28))). -user:metta_file_buffer(64,746002452,metta_typedecl,[:,>,[->,'Number','Number','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1983,0),line_char(1983,29))). -user:metta_file_buffer(65,747002453,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1986,1),line_char(1986,3))). -user:metta_file_buffer(65,747002453,constant,<=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1986,4),line_char(1986,6))). -user:metta_file_buffer(65,747002453,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1986,7),line_char(1986,12))). -user:metta_file_buffer(64,747002453,metta_other,[iz,<=,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1986,0),line_char(1986,13))). -user:metta_file_buffer(65,748002454,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1987,1),line_char(1987,5))). -user:metta_file_buffer(65,748002454,constant,<=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1987,6),line_char(1987,8))). -user:metta_file_buffer(66,748002455,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1988,3),line_char(1988,8))). -user:metta_file_buffer(66,748002455,string,"Less than or equal. Checks if first argument is less than or equal to second one",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1988,9),line_char(1988,91))). -user:metta_file_buffer(65,748002455,metta_other,['@desc',"Less than or equal. Checks if first argument is less than or equal to second one"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1988,2),line_char(1988,92))). -user:metta_file_buffer(66,748002456,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1989,3),line_char(1989,10))). -user:metta_file_buffer(68,748002458,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1990,5),line_char(1990,11))). -user:metta_file_buffer(68,748002458,string,"First number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1990,12),line_char(1990,26))). -user:metta_file_buffer(67,748002458,metta_other,['@param',"First number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1990,4),line_char(1990,27))). -user:metta_file_buffer(68,748002459,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1991,5),line_char(1991,11))). -user:metta_file_buffer(68,748002459,string,"Second number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1991,12),line_char(1991,27))). -user:metta_file_buffer(67,748002459,metta_other,['@param',"Second number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1991,4),line_char(1991,28))). -user:metta_file_buffer(66,748002459,array,[['@param',"First number"],['@param',"Second number"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1989,11),line_char(1991,29))). -user:metta_file_buffer(65,748002459,metta_other,['@params',[['@param',"First number"],['@param',"Second number"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1989,2),line_char(1991,30))). -user:metta_file_buffer(66,748002460,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1992,3),line_char(1992,10))). -user:metta_file_buffer(66,748002460,string,"True if first argument is less than or equal to second, False - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1992,11),line_char(1992,86))). -user:metta_file_buffer(65,748002460,metta_other,['@return',"True if first argument is less than or equal to second, False - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1992,2),line_char(1992,87))). -user:metta_file_buffer(64,748002460,metta_other,['@doc',<=,['@desc',"Less than or equal. Checks if first argument is less than or equal to second one"],['@params',[['@param',"First number"],['@param',"Second number"]]],['@return',"True if first argument is less than or equal to second, False - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1987,0),line_char(1992,88))). -user:metta_file_buffer(65,749002461,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1993,1),line_char(1993,2))). -user:metta_file_buffer(65,749002461,constant,<=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1993,3),line_char(1993,5))). -user:metta_file_buffer(66,749002462,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1993,7),line_char(1993,9))). -user:metta_file_buffer(66,749002462,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1993,10),line_char(1993,16))). -user:metta_file_buffer(66,749002462,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1993,17),line_char(1993,23))). -user:metta_file_buffer(66,749002462,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1993,24),line_char(1993,28))). -user:metta_file_buffer(65,749002462,metta_other,[->,'Number','Number','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1993,6),line_char(1993,29))). -user:metta_file_buffer(64,749002462,metta_typedecl,[:,<=,[->,'Number','Number','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1993,0),line_char(1993,30))). -user:metta_file_buffer(65,750002463,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1996,1),line_char(1996,3))). -user:metta_file_buffer(65,750002463,constant,>=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1996,4),line_char(1996,6))). -user:metta_file_buffer(65,750002463,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1996,7),line_char(1996,12))). -user:metta_file_buffer(64,750002463,metta_other,[iz,>=,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1996,0),line_char(1996,13))). -user:metta_file_buffer(65,751002464,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1997,1),line_char(1997,5))). -user:metta_file_buffer(65,751002464,constant,>=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1997,6),line_char(1997,8))). -user:metta_file_buffer(66,751002465,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1998,3),line_char(1998,8))). -user:metta_file_buffer(66,751002465,string,"Greater than or equal. Checks if first argument is greater than or equal to second one",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1998,9),line_char(1998,97))). -user:metta_file_buffer(65,751002465,metta_other,['@desc',"Greater than or equal. Checks if first argument is greater than or equal to second one"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1998,2),line_char(1998,98))). -user:metta_file_buffer(66,751002466,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1999,3),line_char(1999,10))). -user:metta_file_buffer(68,751002468,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2000,5),line_char(2000,11))). -user:metta_file_buffer(68,751002468,string,"First number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2000,12),line_char(2000,26))). -user:metta_file_buffer(67,751002468,metta_other,['@param',"First number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2000,4),line_char(2000,27))). -user:metta_file_buffer(68,751002469,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2001,5),line_char(2001,11))). -user:metta_file_buffer(68,751002469,string,"Second number",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2001,12),line_char(2001,27))). -user:metta_file_buffer(67,751002469,metta_other,['@param',"Second number"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2001,4),line_char(2001,28))). -user:metta_file_buffer(66,751002469,array,[['@param',"First number"],['@param',"Second number"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1999,11),line_char(2001,29))). -user:metta_file_buffer(65,751002469,metta_other,['@params',[['@param',"First number"],['@param',"Second number"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1999,2),line_char(2001,30))). -user:metta_file_buffer(66,751002470,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2002,3),line_char(2002,10))). -user:metta_file_buffer(66,751002470,string,"True if first argument is greater than or equal to second, False - otherwise",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2002,11),line_char(2002,89))). -user:metta_file_buffer(65,751002470,metta_other,['@return',"True if first argument is greater than or equal to second, False - otherwise"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2002,2),line_char(2002,90))). -user:metta_file_buffer(64,751002470,metta_other,['@doc',>=,['@desc',"Greater than or equal. Checks if first argument is greater than or equal to second one"],['@params',[['@param',"First number"],['@param',"Second number"]]],['@return',"True if first argument is greater than or equal to second, False - otherwise"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(1997,0),line_char(2002,91))). -user:metta_file_buffer(65,752002471,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2003,1),line_char(2003,2))). -user:metta_file_buffer(65,752002471,constant,>=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2003,3),line_char(2003,5))). -user:metta_file_buffer(66,752002472,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2003,7),line_char(2003,9))). -user:metta_file_buffer(66,752002472,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2003,10),line_char(2003,16))). -user:metta_file_buffer(66,752002472,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2003,17),line_char(2003,23))). -user:metta_file_buffer(66,752002472,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2003,24),line_char(2003,28))). -user:metta_file_buffer(65,752002472,metta_other,[->,'Number','Number','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2003,6),line_char(2003,29))). -user:metta_file_buffer(64,752002472,metta_typedecl,[:,>=,[->,'Number','Number','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2003,0),line_char(2003,30))). -user:metta_file_buffer(65,753002473,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2006,1),line_char(2006,3))). -user:metta_file_buffer(65,753002473,constant,==,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2006,4),line_char(2006,6))). -user:metta_file_buffer(65,753002473,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2006,7),line_char(2006,12))). -user:metta_file_buffer(64,753002473,metta_other,[iz,==,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2006,0),line_char(2006,13))). -user:metta_file_buffer(65,754002474,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2007,1),line_char(2007,5))). -user:metta_file_buffer(65,754002474,constant,==,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2007,6),line_char(2007,8))). -user:metta_file_buffer(66,754002475,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2008,3),line_char(2008,8))). -user:metta_file_buffer(66,754002475,string,"Checks equality for two arguments of the same type",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2008,9),line_char(2008,61))). -user:metta_file_buffer(65,754002475,metta_other,['@desc',"Checks equality for two arguments of the same type"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2008,2),line_char(2008,62))). -user:metta_file_buffer(66,754002476,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2009,3),line_char(2009,10))). -user:metta_file_buffer(68,754002478,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2010,5),line_char(2010,11))). -user:metta_file_buffer(68,754002478,string,"First argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2010,12),line_char(2010,28))). -user:metta_file_buffer(67,754002478,metta_other,['@param',"First argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2010,4),line_char(2010,29))). -user:metta_file_buffer(68,754002479,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2011,5),line_char(2011,11))). -user:metta_file_buffer(68,754002479,string,"Second argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2011,12),line_char(2011,29))). -user:metta_file_buffer(67,754002479,metta_other,['@param',"Second argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2011,4),line_char(2011,30))). -user:metta_file_buffer(66,754002479,array,[['@param',"First argument"],['@param',"Second argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2009,11),line_char(2011,31))). -user:metta_file_buffer(65,754002479,metta_other,['@params',[['@param',"First argument"],['@param',"Second argument"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2009,2),line_char(2011,32))). -user:metta_file_buffer(66,754002480,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2012,3),line_char(2012,10))). -user:metta_file_buffer(66,754002480,string,"Returns True if two arguments are equal, False - otherwise. If arguments are of different type function returns Error currently",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2012,11),line_char(2012,140))). -user:metta_file_buffer(65,754002480,metta_other,['@return',"Returns True if two arguments are equal, False - otherwise. If arguments are of different type function returns Error currently"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2012,2),line_char(2012,141))). -user:metta_file_buffer(64,754002480,metta_other,['@doc',==,['@desc',"Checks equality for two arguments of the same type"],['@params',[['@param',"First argument"],['@param',"Second argument"]]],['@return',"Returns True if two arguments are equal, False - otherwise. If arguments are of different type function returns Error currently"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2007,0),line_char(2012,142))). -user:metta_file_buffer(65,755002481,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2013,1),line_char(2013,2))). -user:metta_file_buffer(65,755002481,constant,==,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2013,3),line_char(2013,5))). -user:metta_file_buffer(66,755002482,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2013,7),line_char(2013,9))). -user:metta_file_buffer(66,755002482,variable,_657814,['_t'=_657814],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2013,10),line_char(2013,12))). -user:metta_file_buffer(66,755002482,variable,_659050,['_t'=_659050],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2013,13),line_char(2013,15))). -user:metta_file_buffer(66,755002482,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2013,16),line_char(2013,20))). -user:metta_file_buffer(65,755002482,indexed(metta_other,[->,_660492,_660492,'Bool']),[->,_660570,_660570,'Bool'],['_t'=_660570],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2013,6),line_char(2013,21))). -user:metta_file_buffer(64,755002482,indexed(metta_typedecl,[:,==,[->,_661128,_661128,'Bool']]),[:,==,[->,_661224,_661224,'Bool']],['_t'=_661224],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2013,0),line_char(2013,22))). -user:metta_file_buffer(65,756002483,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2016,1),line_char(2016,3))). -user:metta_file_buffer(65,756002483,constant,xor,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2016,4),line_char(2016,7))). -user:metta_file_buffer(65,756002483,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2016,8),line_char(2016,13))). -user:metta_file_buffer(64,756002483,metta_other,[iz,xor,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2016,0),line_char(2016,14))). -user:metta_file_buffer(65,757002484,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2017,1),line_char(2017,5))). -user:metta_file_buffer(65,757002484,constant,xor,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2017,6),line_char(2017,9))). -user:metta_file_buffer(66,757002485,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2018,3),line_char(2018,8))). -user:metta_file_buffer(66,757002485,string,"Exclusive disjunction of two arguments",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2018,9),line_char(2018,49))). -user:metta_file_buffer(65,757002485,metta_other,['@desc',"Exclusive disjunction of two arguments"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2018,2),line_char(2018,50))). -user:metta_file_buffer(66,757002486,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2019,3),line_char(2019,10))). -user:metta_file_buffer(68,757002488,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2020,5),line_char(2020,11))). -user:metta_file_buffer(68,757002488,string,"First argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2020,12),line_char(2020,28))). -user:metta_file_buffer(67,757002488,metta_other,['@param',"First argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2020,4),line_char(2020,29))). -user:metta_file_buffer(68,757002489,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2021,5),line_char(2021,11))). -user:metta_file_buffer(68,757002489,string,"Second argument",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2021,12),line_char(2021,29))). -user:metta_file_buffer(67,757002489,metta_other,['@param',"Second argument"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2021,4),line_char(2021,30))). -user:metta_file_buffer(66,757002489,array,[['@param',"First argument"],['@param',"Second argument"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2019,11),line_char(2021,31))). -user:metta_file_buffer(65,757002489,metta_other,['@params',[['@param',"First argument"],['@param',"Second argument"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2019,2),line_char(2021,32))). -user:metta_file_buffer(66,757002490,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2022,3),line_char(2022,10))). -user:metta_file_buffer(66,757002490,string,"Return values are the same as logical disjunction, but when both arguments are True xor will return False",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2022,11),line_char(2022,118))). -user:metta_file_buffer(65,757002490,metta_other,['@return',"Return values are the same as logical disjunction, but when both arguments are True xor will return False"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2022,2),line_char(2022,119))). -user:metta_file_buffer(64,757002490,metta_other,['@doc',xor,['@desc',"Exclusive disjunction of two arguments"],['@params',[['@param',"First argument"],['@param',"Second argument"]]],['@return',"Return values are the same as logical disjunction, but when both arguments are True xor will return False"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2017,0),line_char(2022,120))). -user:metta_file_buffer(65,758002491,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2024,1),line_char(2024,2))). -user:metta_file_buffer(65,758002491,constant,xor,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2024,3),line_char(2024,6))). -user:metta_file_buffer(66,758002492,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2024,8),line_char(2024,10))). -user:metta_file_buffer(66,758002492,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2024,11),line_char(2024,15))). -user:metta_file_buffer(66,758002492,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2024,16),line_char(2024,20))). -user:metta_file_buffer(66,758002492,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2024,21),line_char(2024,25))). -user:metta_file_buffer(65,758002492,metta_other,[->,'Bool','Bool','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2024,7),line_char(2024,26))). -user:metta_file_buffer(64,758002492,metta_typedecl,[:,xor,[->,'Bool','Bool','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2024,0),line_char(2024,27))). -user:metta_file_buffer(65,759002493,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2026,1),line_char(2026,3))). -user:metta_file_buffer(65,759002493,constant,flip,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2026,4),line_char(2026,8))). -user:metta_file_buffer(65,759002493,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2026,9),line_char(2026,14))). -user:metta_file_buffer(64,759002493,metta_other,[iz,flip,'MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2026,0),line_char(2026,15))). -user:metta_file_buffer(65,760002494,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2027,1),line_char(2027,5))). -user:metta_file_buffer(65,760002494,constant,flip,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2027,6),line_char(2027,10))). -user:metta_file_buffer(66,760002495,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2028,3),line_char(2028,8))). -user:metta_file_buffer(66,760002495,string,"Produces random boolean value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2028,9),line_char(2028,40))). -user:metta_file_buffer(65,760002495,metta_other,['@desc',"Produces random boolean value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2028,2),line_char(2028,41))). -user:metta_file_buffer(66,760002496,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2029,3),line_char(2029,10))). -user:metta_file_buffer(66,760002497,constant,[],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2029,11),line_char(2029,13))). -user:metta_file_buffer(65,760002497,metta_other,['@params',[]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2029,2),line_char(2029,14))). -user:metta_file_buffer(66,760002498,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2030,3),line_char(2030,10))). -user:metta_file_buffer(66,760002498,string,"Random boolean value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2030,11),line_char(2030,33))). -user:metta_file_buffer(65,760002498,metta_other,['@return',"Random boolean value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2030,2),line_char(2030,34))). -user:metta_file_buffer(64,760002498,metta_other,['@doc',flip,['@desc',"Produces random boolean value"],['@params',[]],['@return',"Random boolean value"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2027,0),line_char(2030,35))). -user:metta_file_buffer(65,761002499,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2033,1),line_char(2033,5))). -user:metta_file_buffer(65,761002499,constant,'unique-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2033,6),line_char(2033,17))). -user:metta_file_buffer(66,761002500,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2034,3),line_char(2034,8))). -user:metta_file_buffer(66,761002500,string,"Function takes tuple and returns only unique entities. E.g. (unique-atom (a b c d d)) -> (a b c d)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2034,9),line_char(2034,109))). -user:metta_file_buffer(65,761002500,metta_other,['@desc',"Function takes tuple and returns only unique entities. E.g. (unique-atom (a b c d d)) -> (a b c d)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2034,2),line_char(2034,110))). -user:metta_file_buffer(66,761002501,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2035,3),line_char(2035,10))). -user:metta_file_buffer(68,761002503,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2036,5),line_char(2036,11))). -user:metta_file_buffer(68,761002503,string,"List of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2036,12),line_char(2036,28))). -user:metta_file_buffer(67,761002503,metta_other,['@param',"List of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2036,4),line_char(2036,29))). -user:metta_file_buffer(66,761002503,array,[['@param',"List of values"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2035,11),line_char(2036,30))). -user:metta_file_buffer(65,761002503,metta_other,['@params',[['@param',"List of values"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2035,2),line_char(2036,31))). -user:metta_file_buffer(66,761002504,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2037,3),line_char(2037,10))). -user:metta_file_buffer(66,761002504,string,"Unique values from input set",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2037,11),line_char(2037,41))). -user:metta_file_buffer(65,761002504,metta_other,['@return',"Unique values from input set"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2037,2),line_char(2037,42))). -user:metta_file_buffer(64,761002504,metta_other,['@doc','unique-atom',['@desc',"Function takes tuple and returns only unique entities. E.g. (unique-atom (a b c d d)) -> (a b c d)"],['@params',[['@param',"List of values"]]],['@return',"Unique values from input set"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2033,0),line_char(2037,43))). -user:metta_file_buffer(65,762002505,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2038,1),line_char(2038,2))). -user:metta_file_buffer(66,762002506,constant,'unique-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2038,4),line_char(2038,15))). -user:metta_file_buffer(66,762002506,variable,_656928,['L1'=_656928],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2038,16),line_char(2038,19))). -user:metta_file_buffer(65,762002506,indexed(metta_other,['unique-atom',_657762]),['unique-atom',_657814],['L1'=_657814],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2038,3),line_char(2038,20))). -user:metta_file_buffer(66,762002507,constant,collapse,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2039,3),line_char(2039,11))). -user:metta_file_buffer(67,762002508,constant,unique,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2039,13),line_char(2039,19))). -user:metta_file_buffer(68,762002509,constant,superpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2039,21),line_char(2039,30))). -user:metta_file_buffer(68,762002509,variable,_660962,['L1'=_660962],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2039,31),line_char(2039,34))). -user:metta_file_buffer(67,762002509,indexed(metta_other,[superpose,_661796]),[superpose,_661848],['L1'=_661848],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2039,20),line_char(2039,35))). -user:metta_file_buffer(66,762002509,indexed(metta_other,[unique,[superpose,_662386]]),[unique,[superpose,_662450]],['L1'=_662450],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2039,12),line_char(2039,36))). -user:metta_file_buffer(65,762002509,indexed(metta_other,[collapse,[unique,[superpose,_663004]]]),[collapse,[unique,[superpose,_663080]]],['L1'=_663080],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2039,2),line_char(2039,37))). -user:metta_file_buffer(64,762002509,indexed(metta_defun,['unique-atom',_663624]),[=,['unique-atom',_663754],[collapse,[unique,[superpose,_663754]]]],['L1'=_663754],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2038,0),line_char(2039,38))). -user:metta_file_buffer(65,763002510,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2040,1),line_char(2040,2))). -user:metta_file_buffer(65,763002510,constant,'unique-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2040,3),line_char(2040,14))). -user:metta_file_buffer(66,763002511,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2040,16),line_char(2040,18))). -user:metta_file_buffer(66,763002511,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2040,19),line_char(2040,29))). -user:metta_file_buffer(66,763002511,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2040,30),line_char(2040,40))). -user:metta_file_buffer(65,763002511,metta_other,[->,'Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2040,15),line_char(2040,41))). -user:metta_file_buffer(64,763002511,metta_typedecl,[:,'unique-atom',[->,'Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2040,0),line_char(2040,42))). -user:metta_file_buffer(65,764002512,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2042,1),line_char(2042,5))). -user:metta_file_buffer(65,764002512,constant,'union-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2042,6),line_char(2042,16))). -user:metta_file_buffer(66,764002513,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2043,3),line_char(2043,8))). -user:metta_file_buffer(66,764002513,string,"Function takes two tuples and returns their union. E.g. (union-atom (a b b c) (b c c d)) -> (a b b c b c c d)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2043,9),line_char(2043,120))). -user:metta_file_buffer(65,764002513,metta_other,['@desc',"Function takes two tuples and returns their union. E.g. (union-atom (a b b c) (b c c d)) -> (a b b c b c c d)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2043,2),line_char(2043,121))). -user:metta_file_buffer(66,764002514,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2044,3),line_char(2044,10))). -user:metta_file_buffer(68,764002516,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2045,5),line_char(2045,11))). -user:metta_file_buffer(68,764002516,string,"List of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2045,12),line_char(2045,28))). -user:metta_file_buffer(67,764002516,metta_other,['@param',"List of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2045,4),line_char(2045,29))). -user:metta_file_buffer(68,764002517,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2046,5),line_char(2046,11))). -user:metta_file_buffer(68,764002517,string,"List of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2046,12),line_char(2046,28))). -user:metta_file_buffer(67,764002517,metta_other,['@param',"List of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2046,4),line_char(2046,29))). -user:metta_file_buffer(66,764002517,array,[['@param',"List of values"],['@param',"List of values"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2044,11),line_char(2046,30))). -user:metta_file_buffer(65,764002517,metta_other,['@params',[['@param',"List of values"],['@param',"List of values"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2044,2),line_char(2046,31))). -user:metta_file_buffer(66,764002518,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2047,3),line_char(2047,10))). -user:metta_file_buffer(66,764002518,string,"Union of sets",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2047,11),line_char(2047,26))). -user:metta_file_buffer(65,764002518,metta_other,['@return',"Union of sets"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2047,2),line_char(2047,27))). -user:metta_file_buffer(64,764002518,metta_other,['@doc','union-atom',['@desc',"Function takes two tuples and returns their union. E.g. (union-atom (a b b c) (b c c d)) -> (a b b c b c c d)"],['@params',[['@param',"List of values"],['@param',"List of values"]]],['@return',"Union of sets"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2042,0),line_char(2047,28))). -user:metta_file_buffer(65,765002519,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2048,1),line_char(2048,2))). -user:metta_file_buffer(66,765002520,constant,'union-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2048,4),line_char(2048,14))). -user:metta_file_buffer(66,765002520,variable,_656910,['L1'=_656910],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2048,15),line_char(2048,18))). -user:metta_file_buffer(66,765002520,variable,_657874,['L2'=_657874],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2048,19),line_char(2048,22))). -user:metta_file_buffer(65,765002520,indexed(metta_other,['union-atom',_658714,_658736]),['union-atom',_658788,_658794],['L2'=_658794,'L1'=_658788],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2048,3),line_char(2048,23))). -user:metta_file_buffer(66,765002521,constant,collapse,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2049,3),line_char(2049,11))). -user:metta_file_buffer(67,765002522,constant,union,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2049,13),line_char(2049,18))). -user:metta_file_buffer(68,765002523,constant,superpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2049,20),line_char(2049,29))). -user:metta_file_buffer(68,765002523,variable,_661944,['L1'=_661944],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2049,30),line_char(2049,33))). -user:metta_file_buffer(67,765002523,indexed(metta_other,[superpose,_662778]),[superpose,_662830],['L1'=_662830],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2049,19),line_char(2049,34))). -user:metta_file_buffer(68,765002524,constant,superpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2049,36),line_char(2049,45))). -user:metta_file_buffer(68,765002524,variable,_664326,['L2'=_664326],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2049,46),line_char(2049,49))). -user:metta_file_buffer(67,765002524,indexed(metta_other,[superpose,_665160]),[superpose,_665212],['L2'=_665212],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2049,35),line_char(2049,50))). -user:metta_file_buffer(66,765002524,indexed(metta_other,[union,[superpose,_665756],[superpose,_665794]]),[union,[superpose,_665858],[superpose,_665876]],['L2'=_665876,'L1'=_665858],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2049,12),line_char(2049,51))). -user:metta_file_buffer(65,765002524,indexed(metta_other,[collapse,[union,[superpose,_666442],[superpose,_666480]]]),[collapse,[union,[superpose,_666556],[superpose,_666574]]],['L2'=_666574,'L1'=_666556],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2049,2),line_char(2049,52))). -user:metta_file_buffer(64,765002524,indexed(metta_defun,['union-atom',_667130,_667152]),[=,['union-atom',_667316,_667322],[collapse,[union,[superpose,_667316],[superpose,_667322]]]],['L2'=_667322,'L1'=_667316],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2048,0),line_char(2049,53))). -user:metta_file_buffer(65,766002525,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2050,1),line_char(2050,2))). -user:metta_file_buffer(65,766002525,constant,'union-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2050,3),line_char(2050,13))). -user:metta_file_buffer(66,766002526,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2050,15),line_char(2050,17))). -user:metta_file_buffer(66,766002526,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2050,18),line_char(2050,28))). -user:metta_file_buffer(66,766002526,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2050,29),line_char(2050,39))). -user:metta_file_buffer(66,766002526,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2050,40),line_char(2050,50))). -user:metta_file_buffer(65,766002526,metta_other,[->,'Expression','Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2050,14),line_char(2050,51))). -user:metta_file_buffer(64,766002526,metta_typedecl,[:,'union-atom',[->,'Expression','Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2050,0),line_char(2050,52))). -user:metta_file_buffer(65,767002527,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2052,1),line_char(2052,5))). -user:metta_file_buffer(65,767002527,constant,'intersection-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2052,6),line_char(2052,23))). -user:metta_file_buffer(66,767002528,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2053,3),line_char(2053,8))). -user:metta_file_buffer(66,767002528,string,"Function takes two tuples and returns their intersection. E.g. (intersection-atom (a b c c) (b c c c d)) -> (b c c)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2053,9),line_char(2053,126))). -user:metta_file_buffer(65,767002528,metta_other,['@desc',"Function takes two tuples and returns their intersection. E.g. (intersection-atom (a b c c) (b c c c d)) -> (b c c)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2053,2),line_char(2053,127))). -user:metta_file_buffer(66,767002529,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2054,3),line_char(2054,10))). -user:metta_file_buffer(68,767002531,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2055,5),line_char(2055,11))). -user:metta_file_buffer(68,767002531,string,"List of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2055,12),line_char(2055,28))). -user:metta_file_buffer(67,767002531,metta_other,['@param',"List of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2055,4),line_char(2055,29))). -user:metta_file_buffer(68,767002532,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2056,5),line_char(2056,11))). -user:metta_file_buffer(68,767002532,string,"List of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2056,12),line_char(2056,28))). -user:metta_file_buffer(67,767002532,metta_other,['@param',"List of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2056,4),line_char(2056,29))). -user:metta_file_buffer(66,767002532,array,[['@param',"List of values"],['@param',"List of values"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2054,11),line_char(2056,30))). -user:metta_file_buffer(65,767002532,metta_other,['@params',[['@param',"List of values"],['@param',"List of values"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2054,2),line_char(2056,31))). -user:metta_file_buffer(66,767002533,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2057,3),line_char(2057,10))). -user:metta_file_buffer(66,767002533,string,"Intersection of sets",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2057,11),line_char(2057,33))). -user:metta_file_buffer(65,767002533,metta_other,['@return',"Intersection of sets"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2057,2),line_char(2057,34))). -user:metta_file_buffer(64,767002533,metta_other,['@doc','intersection-atom',['@desc',"Function takes two tuples and returns their intersection. E.g. (intersection-atom (a b c c) (b c c c d)) -> (b c c)"],['@params',[['@param',"List of values"],['@param',"List of values"]]],['@return',"Intersection of sets"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2052,0),line_char(2057,35))). -user:metta_file_buffer(65,768002534,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2058,1),line_char(2058,2))). -user:metta_file_buffer(66,768002535,constant,'intersection-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2058,4),line_char(2058,21))). -user:metta_file_buffer(66,768002535,variable,_656980,['L1'=_656980],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2058,22),line_char(2058,25))). -user:metta_file_buffer(66,768002535,variable,_657944,['L2'=_657944],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2058,26),line_char(2058,29))). -user:metta_file_buffer(65,768002535,indexed(metta_other,['intersection-atom',_658784,_658806]),['intersection-atom',_658858,_658864],['L2'=_658864,'L1'=_658858],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2058,3),line_char(2058,30))). -user:metta_file_buffer(66,768002536,constant,collapse,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2059,3),line_char(2059,11))). -user:metta_file_buffer(67,768002537,constant,intersection,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2059,13),line_char(2059,25))). -user:metta_file_buffer(68,768002538,constant,superpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2059,27),line_char(2059,36))). -user:metta_file_buffer(68,768002538,variable,_662084,['L1'=_662084],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2059,37),line_char(2059,40))). -user:metta_file_buffer(67,768002538,indexed(metta_other,[superpose,_662918]),[superpose,_662970],['L1'=_662970],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2059,26),line_char(2059,41))). -user:metta_file_buffer(68,768002539,constant,superpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2059,43),line_char(2059,52))). -user:metta_file_buffer(68,768002539,variable,_664466,['L2'=_664466],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2059,53),line_char(2059,56))). -user:metta_file_buffer(67,768002539,indexed(metta_other,[superpose,_665300]),[superpose,_665352],['L2'=_665352],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2059,42),line_char(2059,57))). -user:metta_file_buffer(66,768002539,indexed(metta_other,[intersection,[superpose,_665896],[superpose,_665934]]),[intersection,[superpose,_665998],[superpose,_666016]],['L2'=_666016,'L1'=_665998],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2059,12),line_char(2059,58))). -user:metta_file_buffer(65,768002539,indexed(metta_other,[collapse,[intersection,[superpose,_666582],[superpose,_666620]]]),[collapse,[intersection,[superpose,_666696],[superpose,_666714]]],['L2'=_666714,'L1'=_666696],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2059,2),line_char(2059,59))). -user:metta_file_buffer(64,768002539,indexed(metta_defun,['intersection-atom',_667270,_667292]),[=,['intersection-atom',_667456,_667462],[collapse,[intersection,[superpose,_667456],[superpose,_667462]]]],['L2'=_667462,'L1'=_667456],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2058,0),line_char(2059,60))). -user:metta_file_buffer(65,769002540,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2060,1),line_char(2060,2))). -user:metta_file_buffer(65,769002540,constant,'intersection-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2060,3),line_char(2060,20))). -user:metta_file_buffer(66,769002541,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2060,22),line_char(2060,24))). -user:metta_file_buffer(66,769002541,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2060,25),line_char(2060,35))). -user:metta_file_buffer(66,769002541,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2060,36),line_char(2060,46))). -user:metta_file_buffer(66,769002541,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2060,47),line_char(2060,57))). -user:metta_file_buffer(65,769002541,metta_other,[->,'Expression','Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2060,21),line_char(2060,58))). -user:metta_file_buffer(64,769002541,metta_typedecl,[:,'intersection-atom',[->,'Expression','Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2060,0),line_char(2060,59))). -user:metta_file_buffer(65,770002542,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2062,1),line_char(2062,5))). -user:metta_file_buffer(65,770002542,constant,'subtraction-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2062,6),line_char(2062,22))). -user:metta_file_buffer(66,770002543,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2063,3),line_char(2063,8))). -user:metta_file_buffer(66,770002543,string,"Function takes two tuples and returns their subtraction. E.g. !(subtraction-atom (a b b c) (b c c d)) -> (a b)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2063,9),line_char(2063,121))). -user:metta_file_buffer(65,770002543,metta_other,['@desc',"Function takes two tuples and returns their subtraction. E.g. !(subtraction-atom (a b b c) (b c c d)) -> (a b)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2063,2),line_char(2063,122))). -user:metta_file_buffer(66,770002544,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2064,3),line_char(2064,10))). -user:metta_file_buffer(68,770002546,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2065,5),line_char(2065,11))). -user:metta_file_buffer(68,770002546,string,"List of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2065,12),line_char(2065,28))). -user:metta_file_buffer(67,770002546,metta_other,['@param',"List of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2065,4),line_char(2065,29))). -user:metta_file_buffer(68,770002547,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2066,5),line_char(2066,11))). -user:metta_file_buffer(68,770002547,string,"List of values",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2066,12),line_char(2066,28))). -user:metta_file_buffer(67,770002547,metta_other,['@param',"List of values"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2066,4),line_char(2066,29))). -user:metta_file_buffer(66,770002547,array,[['@param',"List of values"],['@param',"List of values"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2064,11),line_char(2066,30))). -user:metta_file_buffer(65,770002547,metta_other,['@params',[['@param',"List of values"],['@param',"List of values"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2064,2),line_char(2066,31))). -user:metta_file_buffer(66,770002548,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2067,3),line_char(2067,10))). -user:metta_file_buffer(66,770002548,string,"Subtraction of sets",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2067,11),line_char(2067,32))). -user:metta_file_buffer(65,770002548,metta_other,['@return',"Subtraction of sets"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2067,2),line_char(2067,33))). -user:metta_file_buffer(64,770002548,metta_other,['@doc','subtraction-atom',['@desc',"Function takes two tuples and returns their subtraction. E.g. !(subtraction-atom (a b b c) (b c c d)) -> (a b)"],['@params',[['@param',"List of values"],['@param',"List of values"]]],['@return',"Subtraction of sets"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2062,0),line_char(2067,34))). -user:metta_file_buffer(65,771002549,constant,=,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2068,1),line_char(2068,2))). -user:metta_file_buffer(66,771002550,constant,'subtraction-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2068,4),line_char(2068,20))). -user:metta_file_buffer(66,771002550,variable,_656970,['L1'=_656970],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2068,21),line_char(2068,24))). -user:metta_file_buffer(66,771002550,variable,_657934,['L2'=_657934],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2068,25),line_char(2068,28))). -user:metta_file_buffer(65,771002550,indexed(metta_other,['subtraction-atom',_658774,_658796]),['subtraction-atom',_658848,_658854],['L2'=_658854,'L1'=_658848],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2068,3),line_char(2068,29))). -user:metta_file_buffer(66,771002551,constant,collapse,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2069,3),line_char(2069,11))). -user:metta_file_buffer(67,771002552,constant,subtraction,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2069,13),line_char(2069,24))). -user:metta_file_buffer(68,771002553,constant,superpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2069,26),line_char(2069,35))). -user:metta_file_buffer(68,771002553,variable,_662064,['L1'=_662064],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2069,36),line_char(2069,39))). -user:metta_file_buffer(67,771002553,indexed(metta_other,[superpose,_662898]),[superpose,_662950],['L1'=_662950],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2069,25),line_char(2069,40))). -user:metta_file_buffer(68,771002554,constant,superpose,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2069,42),line_char(2069,51))). -user:metta_file_buffer(68,771002554,variable,_664446,['L2'=_664446],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2069,52),line_char(2069,55))). -user:metta_file_buffer(67,771002554,indexed(metta_other,[superpose,_665280]),[superpose,_665332],['L2'=_665332],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2069,41),line_char(2069,56))). -user:metta_file_buffer(66,771002554,indexed(metta_other,[subtraction,[superpose,_665876],[superpose,_665914]]),[subtraction,[superpose,_665978],[superpose,_665996]],['L2'=_665996,'L1'=_665978],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2069,12),line_char(2069,57))). -user:metta_file_buffer(65,771002554,indexed(metta_other,[collapse,[subtraction,[superpose,_666562],[superpose,_666600]]]),[collapse,[subtraction,[superpose,_666676],[superpose,_666694]]],['L2'=_666694,'L1'=_666676],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2069,2),line_char(2069,58))). -user:metta_file_buffer(64,771002554,indexed(metta_defun,['subtraction-atom',_667250,_667272]),[=,['subtraction-atom',_667436,_667442],[collapse,[subtraction,[superpose,_667436],[superpose,_667442]]]],['L2'=_667442,'L1'=_667436],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2068,0),line_char(2069,59))). -user:metta_file_buffer(65,772002555,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2070,1),line_char(2070,2))). -user:metta_file_buffer(65,772002555,constant,'subtraction-atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2070,3),line_char(2070,19))). -user:metta_file_buffer(66,772002556,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2070,21),line_char(2070,23))). -user:metta_file_buffer(66,772002556,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2070,24),line_char(2070,34))). -user:metta_file_buffer(66,772002556,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2070,35),line_char(2070,45))). -user:metta_file_buffer(66,772002556,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2070,46),line_char(2070,56))). -user:metta_file_buffer(65,772002556,metta_other,[->,'Expression','Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2070,20),line_char(2070,57))). -user:metta_file_buffer(64,772002556,metta_typedecl,[:,'subtraction-atom',[->,'Expression','Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2070,0),line_char(2070,58))). -user:metta_file_buffer(65,773002557,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2072,1),line_char(2072,3))). -user:metta_file_buffer(65,773002557,constant,'git-module!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2072,4),line_char(2072,15))). -user:metta_file_buffer(65,773002557,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2072,16),line_char(2072,21))). -user:metta_file_buffer(64,773002557,metta_other,[iz,'git-module!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2072,0),line_char(2072,22))). -user:metta_file_buffer(65,774002558,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2073,1),line_char(2073,5))). -user:metta_file_buffer(65,774002558,constant,'git-module!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2073,6),line_char(2073,17))). -user:metta_file_buffer(66,774002559,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2074,3),line_char(2074,8))). -user:metta_file_buffer(66,774002559,string,"Provides access to module in a remote git repo, from within MeTTa code. Similar to `register-module!`, this op will bypass the catalog search",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2074,9),line_char(2074,152))). -user:metta_file_buffer(65,774002559,metta_other,['@desc',"Provides access to module in a remote git repo, from within MeTTa code. Similar to `register-module!`, this op will bypass the catalog search"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2074,2),line_char(2074,153))). -user:metta_file_buffer(66,774002560,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2075,3),line_char(2075,10))). -user:metta_file_buffer(68,774002562,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2076,5),line_char(2076,11))). -user:metta_file_buffer(68,774002562,string,"URL to github repo",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2076,12),line_char(2076,32))). -user:metta_file_buffer(67,774002562,metta_other,['@param',"URL to github repo"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2076,4),line_char(2076,33))). -user:metta_file_buffer(66,774002562,array,[['@param',"URL to github repo"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2075,11),line_char(2076,34))). -user:metta_file_buffer(65,774002562,metta_other,['@params',[['@param',"URL to github repo"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2075,2),line_char(2076,35))). -user:metta_file_buffer(66,774002563,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2077,3),line_char(2077,10))). -user:metta_file_buffer(66,774002563,string,"Unit atom",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2077,11),line_char(2077,22))). -user:metta_file_buffer(65,774002563,metta_other,['@return',"Unit atom"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2077,2),line_char(2077,23))). -user:metta_file_buffer(64,774002563,metta_other,['@doc','git-module!',['@desc',"Provides access to module in a remote git repo, from within MeTTa code. Similar to `register-module!`, this op will bypass the catalog search"],['@params',[['@param',"URL to github repo"]]],['@return',"Unit atom"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2073,0),line_char(2077,24))). -user:metta_file_buffer(65,775002564,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2078,1),line_char(2078,2))). -user:metta_file_buffer(65,775002564,constant,'git-module!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2078,3),line_char(2078,14))). -user:metta_file_buffer(66,775002565,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2078,16),line_char(2078,18))). -user:metta_file_buffer(66,775002565,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2078,19),line_char(2078,23))). -user:metta_file_buffer(67,775002566,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2078,25),line_char(2078,27))). -user:metta_file_buffer(66,775002566,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2078,24),line_char(2078,28))). -user:metta_file_buffer(65,775002566,metta_other,[->,'Atom',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2078,15),line_char(2078,29))). -user:metta_file_buffer(64,775002566,metta_typedecl,[:,'git-module!',[->,'Atom',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2078,0),line_char(2078,30))). -user:metta_file_buffer(64,776002566,indexed(metta_comment,"; !(import! &corelib \"src/canary/stdlib_mettalog.metta\")"),'$COMMENT'("; !(import! &corelib \"src/canary/stdlib_mettalog.metta\")",2081,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2081,0),line_char(2081,56))). -user:metta_file_buffer(64,776002566,indexed(metta_comment,";!(println! \"!(import! &corelib \\\"src/canary/stdlib_mettalog.metta\\\")\")"),'$COMMENT'(";!(println! \"!(import! &corelib \\\"src/canary/stdlib_mettalog.metta\\\")\")",2082,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2082,0),line_char(2082,71))). -user:metta_file_buffer(65,776002567,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2084,1),line_char(2084,3))). -user:metta_file_buffer(65,776002567,constant,'findall!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2084,4),line_char(2084,12))). -user:metta_file_buffer(65,776002567,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2084,13),line_char(2084,21))). -user:metta_file_buffer(64,776002567,metta_other,[iz,'findall!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2084,0),line_char(2084,22))). -user:metta_file_buffer(65,777002568,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2085,1),line_char(2085,5))). -user:metta_file_buffer(65,777002568,constant,'findall!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2085,6),line_char(2085,14))). -user:metta_file_buffer(66,777002569,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2086,3),line_char(2086,8))). -user:metta_file_buffer(66,777002569,string,"Takes a Template and a Goal. Returns the list resulting from substituting all bindings from solving Goal into Template.\n See Prolog's built-in predicate findall/3.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2086,9),line_char(2087,45))). -user:metta_file_buffer(65,777002569,metta_other,['@desc',"Takes a Template and a Goal. Returns the list resulting from substituting all bindings from solving Goal into Template.\n See Prolog's built-in predicate findall/3."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2086,2),line_char(2087,46))). -user:metta_file_buffer(66,777002570,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2088,3),line_char(2088,10))). -user:metta_file_buffer(68,777002572,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2089,5),line_char(2089,11))). -user:metta_file_buffer(68,777002572,string,"Template",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2089,12),line_char(2089,22))). -user:metta_file_buffer(67,777002572,metta_other,['@param',"Template"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2089,4),line_char(2089,23))). -user:metta_file_buffer(68,777002573,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2090,5),line_char(2090,11))). -user:metta_file_buffer(68,777002573,string,"Goal",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2090,12),line_char(2090,18))). -user:metta_file_buffer(67,777002573,metta_other,['@param',"Goal"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2090,4),line_char(2090,19))). -user:metta_file_buffer(66,777002573,array,[['@param',"Template"],['@param',"Goal"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2088,11),line_char(2090,20))). -user:metta_file_buffer(65,777002573,metta_other,['@params',[['@param',"Template"],['@param',"Goal"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2088,2),line_char(2090,21))). -user:metta_file_buffer(66,777002574,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2091,3),line_char(2091,10))). -user:metta_file_buffer(66,777002574,string,"Result list of all bindings for Goal substituted into Template",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2091,11),line_char(2091,75))). -user:metta_file_buffer(65,777002574,metta_other,['@return',"Result list of all bindings for Goal substituted into Template"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2091,2),line_char(2091,76))). -user:metta_file_buffer(64,777002574,metta_other,['@doc','findall!',['@desc',"Takes a Template and a Goal. Returns the list resulting from substituting all bindings from solving Goal into Template.\n See Prolog's built-in predicate findall/3."],['@params',[['@param',"Template"],['@param',"Goal"]]],['@return',"Result list of all bindings for Goal substituted into Template"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2085,0),line_char(2091,77))). -user:metta_file_buffer(65,778002575,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2092,1),line_char(2092,2))). -user:metta_file_buffer(65,778002575,constant,'findall!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2092,3),line_char(2092,11))). -user:metta_file_buffer(66,778002576,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2092,13),line_char(2092,15))). -user:metta_file_buffer(66,778002576,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2092,16),line_char(2092,26))). -user:metta_file_buffer(66,778002576,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2092,27),line_char(2092,37))). -user:metta_file_buffer(66,778002576,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2092,38),line_char(2092,48))). -user:metta_file_buffer(65,778002576,metta_other,[->,'Expression','Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2092,12),line_char(2092,49))). -user:metta_file_buffer(64,778002576,metta_typedecl,[:,'findall!',[->,'Expression','Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2092,0),line_char(2092,50))). -user:metta_file_buffer(64,779002576,indexed(metta_comment,";; Functional Programming"),'$COMMENT'(";; Functional Programming",2094,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2094,0),line_char(2094,25))). -user:metta_file_buffer(65,779002577,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2095,1),line_char(2095,3))). -user:metta_file_buffer(65,779002577,constant,'maplist!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2095,4),line_char(2095,12))). -user:metta_file_buffer(65,779002577,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2095,13),line_char(2095,21))). -user:metta_file_buffer(64,779002577,metta_other,[iz,'maplist!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2095,0),line_char(2095,22))). -user:metta_file_buffer(65,780002578,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2096,1),line_char(2096,5))). -user:metta_file_buffer(65,780002578,constant,'maplist!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2096,6),line_char(2096,14))). -user:metta_file_buffer(66,780002579,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2097,3),line_char(2097,8))). -user:metta_file_buffer(66,780002579,string,"Takes a function F and one to three lists; Returns the result of applying F to each item in the list(s). \n The provided lists are not evaluated (this matches the behavior of e.g. cons-atom).\n F must have the number of lists provided as a valid arity (i.e. unary for one list, binary for two, ternary for three).\n Use concurrent-maplist! for a multi-threaded, nondeterministic version.\n See Prolog's built-in predicate maplist.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2097,9),line_char(2101,42))). -user:metta_file_buffer(65,780002579,metta_other,['@desc',"Takes a function F and one to three lists; Returns the result of applying F to each item in the list(s). \n The provided lists are not evaluated (this matches the behavior of e.g. cons-atom).\n F must have the number of lists provided as a valid arity (i.e. unary for one list, binary for two, ternary for three).\n Use concurrent-maplist! for a multi-threaded, nondeterministic version.\n See Prolog's built-in predicate maplist."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2097,2),line_char(2101,43))). -user:metta_file_buffer(66,780002580,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2102,3),line_char(2102,10))). -user:metta_file_buffer(68,780002582,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2103,5),line_char(2103,11))). -user:metta_file_buffer(68,780002582,string,"Function to be applied",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2103,12),line_char(2103,36))). -user:metta_file_buffer(67,780002582,metta_other,['@param',"Function to be applied"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2103,4),line_char(2103,37))). -user:metta_file_buffer(68,780002583,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2104,5),line_char(2104,11))). -user:metta_file_buffer(68,780002583,string,"List",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2104,12),line_char(2104,18))). -user:metta_file_buffer(67,780002583,metta_other,['@param',"List"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2104,4),line_char(2104,19))). -user:metta_file_buffer(66,780002583,array,[['@param',"Function to be applied"],['@param',"List"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2102,11),line_char(2104,20))). -user:metta_file_buffer(65,780002583,metta_other,['@params',[['@param',"Function to be applied"],['@param',"List"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2102,2),line_char(2104,21))). -user:metta_file_buffer(66,780002584,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2105,3),line_char(2105,10))). -user:metta_file_buffer(66,780002584,string,"Result of applying Function to List(s)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2105,11),line_char(2105,51))). -user:metta_file_buffer(65,780002584,metta_other,['@return',"Result of applying Function to List(s)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2105,2),line_char(2105,52))). -user:metta_file_buffer(64,780002584,metta_other,['@doc','maplist!',['@desc',"Takes a function F and one to three lists; Returns the result of applying F to each item in the list(s). \n The provided lists are not evaluated (this matches the behavior of e.g. cons-atom).\n F must have the number of lists provided as a valid arity (i.e. unary for one list, binary for two, ternary for three).\n Use concurrent-maplist! for a multi-threaded, nondeterministic version.\n See Prolog's built-in predicate maplist."],['@params',[['@param',"Function to be applied"],['@param',"List"]]],['@return',"Result of applying Function to List(s)"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2096,0),line_char(2105,53))). -user:metta_file_buffer(65,781002585,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2106,1),line_char(2106,2))). -user:metta_file_buffer(65,781002585,constant,'maplist!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2106,3),line_char(2106,11))). -user:metta_file_buffer(66,781002586,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2106,13),line_char(2106,15))). -user:metta_file_buffer(66,781002586,constant,'Function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2106,16),line_char(2106,24))). -user:metta_file_buffer(66,781002586,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2106,25),line_char(2106,35))). -user:metta_file_buffer(66,781002586,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2106,36),line_char(2106,46))). -user:metta_file_buffer(65,781002586,metta_other,[->,'Function','Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2106,12),line_char(2106,47))). -user:metta_file_buffer(64,781002586,metta_typedecl,[:,'maplist!',[->,'Function','Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2106,0),line_char(2106,48))). -user:metta_file_buffer(65,782002587,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2107,1),line_char(2107,2))). -user:metta_file_buffer(65,782002587,constant,'maplist!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2107,3),line_char(2107,11))). -user:metta_file_buffer(66,782002588,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2107,13),line_char(2107,15))). -user:metta_file_buffer(66,782002588,constant,'Function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2107,16),line_char(2107,24))). -user:metta_file_buffer(66,782002588,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2107,25),line_char(2107,35))). -user:metta_file_buffer(66,782002588,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2107,36),line_char(2107,46))). -user:metta_file_buffer(66,782002588,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2107,47),line_char(2107,57))). -user:metta_file_buffer(65,782002588,metta_other,[->,'Function','Expression','Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2107,12),line_char(2107,58))). -user:metta_file_buffer(64,782002588,metta_typedecl,[:,'maplist!',[->,'Function','Expression','Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2107,0),line_char(2107,59))). -user:metta_file_buffer(65,783002589,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2108,1),line_char(2108,2))). -user:metta_file_buffer(65,783002589,constant,'maplist!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2108,3),line_char(2108,11))). -user:metta_file_buffer(66,783002590,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2108,13),line_char(2108,15))). -user:metta_file_buffer(66,783002590,constant,'Function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2108,16),line_char(2108,24))). -user:metta_file_buffer(66,783002590,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2108,25),line_char(2108,35))). -user:metta_file_buffer(66,783002590,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2108,36),line_char(2108,46))). -user:metta_file_buffer(66,783002590,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2108,47),line_char(2108,57))). -user:metta_file_buffer(66,783002590,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2108,58),line_char(2108,68))). -user:metta_file_buffer(65,783002590,metta_other,[->,'Function','Expression','Expression','Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2108,12),line_char(2108,69))). -user:metta_file_buffer(64,783002590,metta_typedecl,[:,'maplist!',[->,'Function','Expression','Expression','Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2108,0),line_char(2108,70))). -user:metta_file_buffer(64,784002590,indexed(metta_comment,";; Functional Programming"),'$COMMENT'(";; Functional Programming",2110,0),[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2110,0),line_char(2110,25))). -user:metta_file_buffer(65,784002591,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2111,1),line_char(2111,3))). -user:metta_file_buffer(65,784002591,constant,'concurrent-maplist!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2111,4),line_char(2111,23))). -user:metta_file_buffer(65,784002591,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2111,24),line_char(2111,32))). -user:metta_file_buffer(64,784002591,metta_other,[iz,'concurrent-maplist!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2111,0),line_char(2111,33))). -user:metta_file_buffer(65,785002592,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2112,1),line_char(2112,5))). -user:metta_file_buffer(65,785002592,constant,'concurrent-maplist!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2112,6),line_char(2112,25))). -user:metta_file_buffer(66,785002593,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2113,3),line_char(2113,8))). -user:metta_file_buffer(66,785002593,string,"Takes a function F and one to three lists; Returns the result of applying F to each item in the list(s). \n The provided lists are not evaluated (this matches the behavior of e.g. cons-atom).\n F must have the number of lists provided as a valid arity (i.e. unary for one list, binary for two, ternary for three).\n The applications of F to the list items are processed in parallel. Because of the overhead of this approach, a speedup is only likely if F is expensive to evaluate.\n Use maplist! for a single-threaded, deterministic version.\n See Prolog's built-in predicate concurrent-maplist.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2113,9),line_char(2118,53))). -user:metta_file_buffer(65,785002593,metta_other,['@desc',"Takes a function F and one to three lists; Returns the result of applying F to each item in the list(s). \n The provided lists are not evaluated (this matches the behavior of e.g. cons-atom).\n F must have the number of lists provided as a valid arity (i.e. unary for one list, binary for two, ternary for three).\n The applications of F to the list items are processed in parallel. Because of the overhead of this approach, a speedup is only likely if F is expensive to evaluate.\n Use maplist! for a single-threaded, deterministic version.\n See Prolog's built-in predicate concurrent-maplist."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2113,2),line_char(2118,54))). -user:metta_file_buffer(66,785002594,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2119,3),line_char(2119,10))). -user:metta_file_buffer(68,785002596,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2120,5),line_char(2120,11))). -user:metta_file_buffer(68,785002596,string,"Function to be applied",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2120,12),line_char(2120,36))). -user:metta_file_buffer(67,785002596,metta_other,['@param',"Function to be applied"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2120,4),line_char(2120,37))). -user:metta_file_buffer(68,785002597,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2121,5),line_char(2121,11))). -user:metta_file_buffer(68,785002597,string,"List",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2121,12),line_char(2121,18))). -user:metta_file_buffer(67,785002597,metta_other,['@param',"List"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2121,4),line_char(2121,19))). -user:metta_file_buffer(66,785002597,array,[['@param',"Function to be applied"],['@param',"List"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2119,11),line_char(2121,20))). -user:metta_file_buffer(65,785002597,metta_other,['@params',[['@param',"Function to be applied"],['@param',"List"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2119,2),line_char(2121,21))). -user:metta_file_buffer(66,785002598,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2122,3),line_char(2122,10))). -user:metta_file_buffer(66,785002598,string,"Result of applying Function to List(s)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2122,11),line_char(2122,51))). -user:metta_file_buffer(65,785002598,metta_other,['@return',"Result of applying Function to List(s)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2122,2),line_char(2122,52))). -user:metta_file_buffer(64,785002598,metta_other,['@doc','concurrent-maplist!',['@desc',"Takes a function F and one to three lists; Returns the result of applying F to each item in the list(s). \n The provided lists are not evaluated (this matches the behavior of e.g. cons-atom).\n F must have the number of lists provided as a valid arity (i.e. unary for one list, binary for two, ternary for three).\n The applications of F to the list items are processed in parallel. Because of the overhead of this approach, a speedup is only likely if F is expensive to evaluate.\n Use maplist! for a single-threaded, deterministic version.\n See Prolog's built-in predicate concurrent-maplist."],['@params',[['@param',"Function to be applied"],['@param',"List"]]],['@return',"Result of applying Function to List(s)"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2112,0),line_char(2122,53))). -user:metta_file_buffer(65,786002599,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2123,1),line_char(2123,2))). -user:metta_file_buffer(65,786002599,constant,'concurrent-maplist!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2123,3),line_char(2123,22))). -user:metta_file_buffer(66,786002600,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2123,24),line_char(2123,26))). -user:metta_file_buffer(66,786002600,constant,'Function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2123,27),line_char(2123,35))). -user:metta_file_buffer(66,786002600,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2123,36),line_char(2123,46))). -user:metta_file_buffer(66,786002600,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2123,47),line_char(2123,57))). -user:metta_file_buffer(65,786002600,metta_other,[->,'Function','Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2123,23),line_char(2123,58))). -user:metta_file_buffer(64,786002600,metta_typedecl,[:,'concurrent-maplist!',[->,'Function','Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2123,0),line_char(2123,59))). -user:metta_file_buffer(65,787002601,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2124,1),line_char(2124,2))). -user:metta_file_buffer(65,787002601,constant,'concurrent-maplist!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2124,3),line_char(2124,22))). -user:metta_file_buffer(66,787002602,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2124,24),line_char(2124,26))). -user:metta_file_buffer(66,787002602,constant,'Function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2124,27),line_char(2124,35))). -user:metta_file_buffer(66,787002602,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2124,36),line_char(2124,46))). -user:metta_file_buffer(66,787002602,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2124,47),line_char(2124,57))). -user:metta_file_buffer(66,787002602,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2124,58),line_char(2124,68))). -user:metta_file_buffer(65,787002602,metta_other,[->,'Function','Expression','Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2124,23),line_char(2124,69))). -user:metta_file_buffer(64,787002602,metta_typedecl,[:,'concurrent-maplist!',[->,'Function','Expression','Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2124,0),line_char(2124,70))). -user:metta_file_buffer(65,788002603,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2125,1),line_char(2125,2))). -user:metta_file_buffer(65,788002603,constant,'concurrent-maplist!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2125,3),line_char(2125,22))). -user:metta_file_buffer(66,788002604,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2125,24),line_char(2125,26))). -user:metta_file_buffer(66,788002604,constant,'Function',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2125,27),line_char(2125,35))). -user:metta_file_buffer(66,788002604,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2125,36),line_char(2125,46))). -user:metta_file_buffer(66,788002604,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2125,47),line_char(2125,57))). -user:metta_file_buffer(66,788002604,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2125,58),line_char(2125,68))). -user:metta_file_buffer(66,788002604,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2125,69),line_char(2125,79))). -user:metta_file_buffer(65,788002604,metta_other,[->,'Function','Expression','Expression','Expression','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2125,23),line_char(2125,80))). -user:metta_file_buffer(64,788002604,metta_typedecl,[:,'concurrent-maplist!',[->,'Function','Expression','Expression','Expression','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2125,0),line_char(2125,81))). -user:metta_file_buffer(65,789002605,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2127,1),line_char(2127,3))). -user:metta_file_buffer(65,789002605,constant,throw,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2127,4),line_char(2127,9))). -user:metta_file_buffer(65,789002605,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2127,10),line_char(2127,18))). -user:metta_file_buffer(64,789002605,metta_other,[iz,throw,'MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2127,0),line_char(2127,19))). -user:metta_file_buffer(65,790002606,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2128,1),line_char(2128,5))). -user:metta_file_buffer(65,790002606,constant,throw,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2128,6),line_char(2128,11))). -user:metta_file_buffer(66,790002607,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2129,3),line_char(2129,8))). -user:metta_file_buffer(66,790002607,string,"Raises an exception. See also `catch`; the system will look for the innermost catch such that Exception unifies with Catcher.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2129,9),line_char(2129,136))). -user:metta_file_buffer(65,790002607,metta_other,['@desc',"Raises an exception. See also `catch`; the system will look for the innermost catch such that Exception unifies with Catcher."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2129,2),line_char(2129,137))). -user:metta_file_buffer(66,790002608,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2130,3),line_char(2130,10))). -user:metta_file_buffer(68,790002610,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2131,5),line_char(2131,11))). -user:metta_file_buffer(68,790002610,string,"Exception",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2131,12),line_char(2131,23))). -user:metta_file_buffer(67,790002610,metta_other,['@param',"Exception"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2131,4),line_char(2131,24))). -user:metta_file_buffer(66,790002610,array,[['@param',"Exception"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2130,11),line_char(2131,25))). -user:metta_file_buffer(65,790002610,metta_other,['@params',[['@param',"Exception"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2130,2),line_char(2131,26))). -user:metta_file_buffer(66,790002611,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2132,3),line_char(2132,10))). -user:metta_file_buffer(66,790002611,string,"Does not return - raises an exception",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2132,11),line_char(2132,50))). -user:metta_file_buffer(65,790002611,metta_other,['@return',"Does not return - raises an exception"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2132,2),line_char(2132,51))). -user:metta_file_buffer(64,790002611,metta_other,['@doc',throw,['@desc',"Raises an exception. See also `catch`; the system will look for the innermost catch such that Exception unifies with Catcher."],['@params',[['@param',"Exception"]]],['@return',"Does not return - raises an exception"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2128,0),line_char(2132,52))). -user:metta_file_buffer(65,791002612,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2133,1),line_char(2133,2))). -user:metta_file_buffer(65,791002612,constant,throw,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2133,3),line_char(2133,8))). -user:metta_file_buffer(66,791002613,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2133,10),line_char(2133,12))). -user:metta_file_buffer(66,791002613,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2133,13),line_char(2133,17))). -user:metta_file_buffer(66,791002613,constant,'ErrorType',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2133,18),line_char(2133,27))). -user:metta_file_buffer(65,791002613,metta_other,[->,'Atom','ErrorType'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2133,9),line_char(2133,28))). -user:metta_file_buffer(64,791002613,metta_typedecl,[:,throw,[->,'Atom','ErrorType']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2133,0),line_char(2133,29))). -user:metta_file_buffer(65,792002614,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2135,1),line_char(2135,3))). -user:metta_file_buffer(65,792002614,constant,catch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2135,4),line_char(2135,9))). -user:metta_file_buffer(65,792002614,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2135,10),line_char(2135,18))). -user:metta_file_buffer(64,792002614,metta_other,[iz,catch,'MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2135,0),line_char(2135,19))). -user:metta_file_buffer(65,793002615,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2136,1),line_char(2136,5))). -user:metta_file_buffer(65,793002615,constant,catch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2136,6),line_char(2136,11))). -user:metta_file_buffer(66,793002616,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2137,3),line_char(2137,8))). -user:metta_file_buffer(66,793002616,string,"Executes Form. If an exception is raised with `throw` during execution of Form while this is the innermost catch such that Catcher unifies with Exception, the exception is caught. Recover is then executed with bindings from Catcher.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2137,9),line_char(2137,243))). -user:metta_file_buffer(65,793002616,metta_other,['@desc',"Executes Form. If an exception is raised with `throw` during execution of Form while this is the innermost catch such that Catcher unifies with Exception, the exception is caught. Recover is then executed with bindings from Catcher."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2137,2),line_char(2137,244))). -user:metta_file_buffer(66,793002617,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2138,3),line_char(2138,10))). -user:metta_file_buffer(68,793002619,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2139,5),line_char(2139,11))). -user:metta_file_buffer(68,793002619,string,"Form",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2139,12),line_char(2139,18))). -user:metta_file_buffer(67,793002619,metta_other,['@param',"Form"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2139,4),line_char(2139,19))). -user:metta_file_buffer(68,793002620,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2140,5),line_char(2140,11))). -user:metta_file_buffer(68,793002620,string,"Catcher",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2140,12),line_char(2140,21))). -user:metta_file_buffer(67,793002620,metta_other,['@param',"Catcher"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2140,4),line_char(2140,22))). -user:metta_file_buffer(68,793002621,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2141,5),line_char(2141,11))). -user:metta_file_buffer(68,793002621,string,"Recover",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2141,12),line_char(2141,21))). -user:metta_file_buffer(67,793002621,metta_other,['@param',"Recover"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2141,4),line_char(2141,22))). -user:metta_file_buffer(66,793002621,array,[['@param',"Form"],['@param',"Catcher"],['@param',"Recover"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2138,11),line_char(2141,23))). -user:metta_file_buffer(65,793002621,metta_other,['@params',[['@param',"Form"],['@param',"Catcher"],['@param',"Recover"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2138,2),line_char(2141,24))). -user:metta_file_buffer(66,793002622,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2142,3),line_char(2142,10))). -user:metta_file_buffer(66,793002622,string,"Result of Form if no exception is raised. Result of Recover (with bindings from Catcher) if an exception is caught.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2142,11),line_char(2142,128))). -user:metta_file_buffer(65,793002622,metta_other,['@return',"Result of Form if no exception is raised. Result of Recover (with bindings from Catcher) if an exception is caught."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2142,2),line_char(2142,129))). -user:metta_file_buffer(64,793002622,metta_other,['@doc',catch,['@desc',"Executes Form. If an exception is raised with `throw` during execution of Form while this is the innermost catch such that Catcher unifies with Exception, the exception is caught. Recover is then executed with bindings from Catcher."],['@params',[['@param',"Form"],['@param',"Catcher"],['@param',"Recover"]]],['@return',"Result of Form if no exception is raised. Result of Recover (with bindings from Catcher) if an exception is caught."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2136,0),line_char(2142,130))). -user:metta_file_buffer(65,794002623,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2143,1),line_char(2143,2))). -user:metta_file_buffer(65,794002623,constant,catch,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2143,3),line_char(2143,8))). -user:metta_file_buffer(66,794002624,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2143,10),line_char(2143,12))). -user:metta_file_buffer(66,794002624,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2143,13),line_char(2143,17))). -user:metta_file_buffer(66,794002624,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2143,18),line_char(2143,22))). -user:metta_file_buffer(66,794002624,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2143,23),line_char(2143,27))). -user:metta_file_buffer(66,794002624,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2143,28),line_char(2143,32))). -user:metta_file_buffer(65,794002624,metta_other,[->,'Atom','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2143,9),line_char(2143,33))). -user:metta_file_buffer(64,794002624,metta_typedecl,[:,catch,[->,'Atom','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2143,0),line_char(2143,34))). -user:metta_file_buffer(65,795002625,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2145,1),line_char(2145,3))). -user:metta_file_buffer(65,795002625,constant,'max-time!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2145,4),line_char(2145,13))). -user:metta_file_buffer(65,795002625,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2145,14),line_char(2145,22))). -user:metta_file_buffer(64,795002625,metta_other,[iz,'max-time!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2145,0),line_char(2145,23))). -user:metta_file_buffer(65,796002626,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2146,1),line_char(2146,5))). -user:metta_file_buffer(65,796002626,constant,'max-time!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2146,6),line_char(2146,15))). -user:metta_file_buffer(66,796002627,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2147,3),line_char(2147,8))). -user:metta_file_buffer(66,796002627,string,"Executes Form. If execution takes longer than Time, will raise a time_limit_exceeded exception. See also `catch`.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2147,9),line_char(2147,124))). -user:metta_file_buffer(65,796002627,metta_other,['@desc',"Executes Form. If execution takes longer than Time, will raise a time_limit_exceeded exception. See also `catch`."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2147,2),line_char(2147,125))). -user:metta_file_buffer(66,796002628,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2148,3),line_char(2148,10))). -user:metta_file_buffer(68,796002630,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2149,5),line_char(2149,11))). -user:metta_file_buffer(68,796002630,string,"Time (in seconds)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2149,12),line_char(2149,31))). -user:metta_file_buffer(67,796002630,metta_other,['@param',"Time (in seconds)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2149,4),line_char(2149,32))). -user:metta_file_buffer(68,796002631,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2150,5),line_char(2150,11))). -user:metta_file_buffer(68,796002631,string,"Form",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2150,12),line_char(2150,18))). -user:metta_file_buffer(67,796002631,metta_other,['@param',"Form"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2150,4),line_char(2150,19))). -user:metta_file_buffer(66,796002631,array,[['@param',"Time (in seconds)"],['@param',"Form"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2148,11),line_char(2150,20))). -user:metta_file_buffer(65,796002631,metta_other,['@params',[['@param',"Time (in seconds)"],['@param',"Form"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2148,2),line_char(2150,21))). -user:metta_file_buffer(66,796002632,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2151,3),line_char(2151,10))). -user:metta_file_buffer(66,796002632,string,"Result of Form if execution completes within Time. Raises an exception otherwise.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2151,11),line_char(2151,94))). -user:metta_file_buffer(65,796002632,metta_other,['@return',"Result of Form if execution completes within Time. Raises an exception otherwise."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2151,2),line_char(2151,95))). -user:metta_file_buffer(64,796002632,metta_other,['@doc','max-time!',['@desc',"Executes Form. If execution takes longer than Time, will raise a time_limit_exceeded exception. See also `catch`."],['@params',[['@param',"Time (in seconds)"],['@param',"Form"]]],['@return',"Result of Form if execution completes within Time. Raises an exception otherwise."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2146,0),line_char(2151,96))). -user:metta_file_buffer(65,797002633,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2152,1),line_char(2152,2))). -user:metta_file_buffer(65,797002633,constant,'max-time!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2152,3),line_char(2152,12))). -user:metta_file_buffer(66,797002634,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2152,14),line_char(2152,16))). -user:metta_file_buffer(66,797002634,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2152,17),line_char(2152,23))). -user:metta_file_buffer(66,797002634,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2152,24),line_char(2152,28))). -user:metta_file_buffer(66,797002634,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2152,29),line_char(2152,33))). -user:metta_file_buffer(65,797002634,metta_other,[->,'Number','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2152,13),line_char(2152,34))). -user:metta_file_buffer(64,797002634,metta_typedecl,[:,'max-time!',[->,'Number','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2152,0),line_char(2152,35))). -user:metta_file_buffer(65,798002635,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2154,1),line_char(2154,3))). -user:metta_file_buffer(65,798002635,constant,'sleep!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2154,4),line_char(2154,10))). -user:metta_file_buffer(65,798002635,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2154,11),line_char(2154,19))). -user:metta_file_buffer(64,798002635,metta_other,[iz,'sleep!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2154,0),line_char(2154,20))). -user:metta_file_buffer(65,799002636,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2155,1),line_char(2155,5))). -user:metta_file_buffer(65,799002636,constant,'sleep!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2155,6),line_char(2155,12))). -user:metta_file_buffer(66,799002637,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2156,3),line_char(2156,8))). -user:metta_file_buffer(66,799002637,string,"Sleeps for N seconds.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2156,9),line_char(2156,32))). -user:metta_file_buffer(65,799002637,metta_other,['@desc',"Sleeps for N seconds."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2156,2),line_char(2156,33))). -user:metta_file_buffer(66,799002638,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2157,3),line_char(2157,10))). -user:metta_file_buffer(68,799002640,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2158,5),line_char(2158,11))). -user:metta_file_buffer(68,799002640,string,"N",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2158,12),line_char(2158,15))). -user:metta_file_buffer(67,799002640,metta_other,['@param',"N"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2158,4),line_char(2158,16))). -user:metta_file_buffer(66,799002640,array,[['@param',"N"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2157,11),line_char(2158,17))). -user:metta_file_buffer(65,799002640,metta_other,['@params',[['@param',"N"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2157,2),line_char(2158,18))). -user:metta_file_buffer(66,799002641,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2159,3),line_char(2159,10))). -user:metta_file_buffer(66,799002641,string,"Returns True after sleeping completes.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2159,11),line_char(2159,51))). -user:metta_file_buffer(65,799002641,metta_other,['@return',"Returns True after sleeping completes."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2159,2),line_char(2159,52))). -user:metta_file_buffer(64,799002641,metta_other,['@doc','sleep!',['@desc',"Sleeps for N seconds."],['@params',[['@param',"N"]]],['@return',"Returns True after sleeping completes."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2155,0),line_char(2159,53))). -user:metta_file_buffer(65,800002642,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2160,1),line_char(2160,2))). -user:metta_file_buffer(65,800002642,constant,'sleep!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2160,3),line_char(2160,9))). -user:metta_file_buffer(66,800002643,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2160,11),line_char(2160,13))). -user:metta_file_buffer(66,800002643,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2160,14),line_char(2160,20))). -user:metta_file_buffer(66,800002643,constant,'Bool',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2160,21),line_char(2160,25))). -user:metta_file_buffer(65,800002643,metta_other,[->,'Number','Bool'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2160,10),line_char(2160,26))). -user:metta_file_buffer(64,800002643,metta_typedecl,[:,'sleep!',[->,'Number','Bool']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2160,0),line_char(2160,27))). -user:metta_file_buffer(65,801002644,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2162,1),line_char(2162,3))). -user:metta_file_buffer(65,801002644,constant,'limit!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2162,4),line_char(2162,10))). -user:metta_file_buffer(65,801002644,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2162,11),line_char(2162,19))). -user:metta_file_buffer(64,801002644,metta_other,[iz,'limit!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2162,0),line_char(2162,20))). -user:metta_file_buffer(65,802002645,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2163,1),line_char(2163,5))). -user:metta_file_buffer(65,802002645,constant,'limit!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2163,6),line_char(2163,12))). -user:metta_file_buffer(66,802002646,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2164,3),line_char(2164,8))). -user:metta_file_buffer(66,802002646,string,"Executes Form generating at most Limit results. Results are returned as soon as they become available.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2164,9),line_char(2164,113))). -user:metta_file_buffer(65,802002646,metta_other,['@desc',"Executes Form generating at most Limit results. Results are returned as soon as they become available."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2164,2),line_char(2164,114))). -user:metta_file_buffer(66,802002647,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2165,3),line_char(2165,10))). -user:metta_file_buffer(68,802002649,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2166,5),line_char(2166,11))). -user:metta_file_buffer(68,802002649,string,"Limit",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2166,12),line_char(2166,19))). -user:metta_file_buffer(67,802002649,metta_other,['@param',"Limit"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2166,4),line_char(2166,20))). -user:metta_file_buffer(68,802002650,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2167,5),line_char(2167,11))). -user:metta_file_buffer(68,802002650,string,"Form",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2167,12),line_char(2167,18))). -user:metta_file_buffer(67,802002650,metta_other,['@param',"Form"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2167,4),line_char(2167,19))). -user:metta_file_buffer(66,802002650,array,[['@param',"Limit"],['@param',"Form"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2165,11),line_char(2167,20))). -user:metta_file_buffer(65,802002650,metta_other,['@params',[['@param',"Limit"],['@param',"Form"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2165,2),line_char(2167,21))). -user:metta_file_buffer(66,802002651,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2168,3),line_char(2168,10))). -user:metta_file_buffer(66,802002651,string,"First Limit results of Form.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2168,11),line_char(2168,41))). -user:metta_file_buffer(65,802002651,metta_other,['@return',"First Limit results of Form."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2168,2),line_char(2168,42))). -user:metta_file_buffer(64,802002651,metta_other,['@doc','limit!',['@desc',"Executes Form generating at most Limit results. Results are returned as soon as they become available."],['@params',[['@param',"Limit"],['@param',"Form"]]],['@return',"First Limit results of Form."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2163,0),line_char(2168,43))). -user:metta_file_buffer(65,803002652,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2169,1),line_char(2169,2))). -user:metta_file_buffer(65,803002652,constant,'limit!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2169,3),line_char(2169,9))). -user:metta_file_buffer(66,803002653,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2169,11),line_char(2169,13))). -user:metta_file_buffer(66,803002653,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2169,14),line_char(2169,20))). -user:metta_file_buffer(66,803002653,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2169,21),line_char(2169,25))). -user:metta_file_buffer(66,803002653,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2169,26),line_char(2169,30))). -user:metta_file_buffer(65,803002653,metta_other,[->,'Number','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2169,10),line_char(2169,31))). -user:metta_file_buffer(64,803002653,metta_typedecl,[:,'limit!',[->,'Number','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2169,0),line_char(2169,32))). -user:metta_file_buffer(65,804002654,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2171,1),line_char(2171,3))). -user:metta_file_buffer(65,804002654,constant,'number-of',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2171,4),line_char(2171,13))). -user:metta_file_buffer(65,804002654,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2171,14),line_char(2171,22))). -user:metta_file_buffer(64,804002654,metta_other,[iz,'number-of','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2171,0),line_char(2171,23))). -user:metta_file_buffer(65,805002655,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2172,1),line_char(2172,5))). -user:metta_file_buffer(65,805002655,constant,'number-of',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2172,6),line_char(2172,15))). -user:metta_file_buffer(66,805002656,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2173,3),line_char(2173,8))). -user:metta_file_buffer(66,805002656,string,"Returns the number of results Form generates",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2173,9),line_char(2173,55))). -user:metta_file_buffer(65,805002656,metta_other,['@desc',"Returns the number of results Form generates"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2173,2),line_char(2173,56))). -user:metta_file_buffer(66,805002657,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2174,3),line_char(2174,10))). -user:metta_file_buffer(68,805002659,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2175,5),line_char(2175,11))). -user:metta_file_buffer(68,805002659,string,"Form",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2175,12),line_char(2175,18))). -user:metta_file_buffer(67,805002659,metta_other,['@param',"Form"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2175,4),line_char(2175,19))). -user:metta_file_buffer(66,805002659,array,[['@param',"Form"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2174,11),line_char(2175,20))). -user:metta_file_buffer(65,805002659,metta_other,['@params',[['@param',"Form"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2174,2),line_char(2175,21))). -user:metta_file_buffer(66,805002660,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2176,3),line_char(2176,10))). -user:metta_file_buffer(66,805002660,string,"Number of results of Form.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2176,11),line_char(2176,39))). -user:metta_file_buffer(65,805002660,metta_other,['@return',"Number of results of Form."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2176,2),line_char(2176,40))). -user:metta_file_buffer(64,805002660,metta_other,['@doc','number-of',['@desc',"Returns the number of results Form generates"],['@params',[['@param',"Form"]]],['@return',"Number of results of Form."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2172,0),line_char(2176,41))). -user:metta_file_buffer(65,806002661,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2177,1),line_char(2177,2))). -user:metta_file_buffer(65,806002661,constant,'number-of',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2177,3),line_char(2177,12))). -user:metta_file_buffer(66,806002662,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2177,14),line_char(2177,16))). -user:metta_file_buffer(66,806002662,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2177,17),line_char(2177,21))). -user:metta_file_buffer(66,806002662,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2177,22),line_char(2177,28))). -user:metta_file_buffer(65,806002662,metta_other,[->,'Atom','Number'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2177,13),line_char(2177,29))). -user:metta_file_buffer(64,806002662,metta_typedecl,[:,'number-of',[->,'Atom','Number']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2177,0),line_char(2177,30))). -user:metta_file_buffer(65,807002663,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2179,1),line_char(2179,3))). -user:metta_file_buffer(65,807002663,constant,'offset!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2179,4),line_char(2179,11))). -user:metta_file_buffer(65,807002663,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2179,12),line_char(2179,20))). -user:metta_file_buffer(64,807002663,metta_other,[iz,'offset!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2179,0),line_char(2179,21))). -user:metta_file_buffer(65,808002664,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2180,1),line_char(2180,5))). -user:metta_file_buffer(65,808002664,constant,'offset!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2180,6),line_char(2180,13))). -user:metta_file_buffer(66,808002665,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2181,3),line_char(2181,8))). -user:metta_file_buffer(66,808002665,string,"Executes Form ignoring the first Count results. Results are returned as soon as they become available.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2181,9),line_char(2181,113))). -user:metta_file_buffer(65,808002665,metta_other,['@desc',"Executes Form ignoring the first Count results. Results are returned as soon as they become available."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2181,2),line_char(2181,114))). -user:metta_file_buffer(66,808002666,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2182,3),line_char(2182,10))). -user:metta_file_buffer(68,808002668,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2183,5),line_char(2183,11))). -user:metta_file_buffer(68,808002668,string,"Count",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2183,12),line_char(2183,19))). -user:metta_file_buffer(67,808002668,metta_other,['@param',"Count"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2183,4),line_char(2183,20))). -user:metta_file_buffer(68,808002669,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2184,5),line_char(2184,11))). -user:metta_file_buffer(68,808002669,string,"Form",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2184,12),line_char(2184,18))). -user:metta_file_buffer(67,808002669,metta_other,['@param',"Form"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2184,4),line_char(2184,19))). -user:metta_file_buffer(66,808002669,array,[['@param',"Count"],['@param',"Form"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2182,11),line_char(2184,20))). -user:metta_file_buffer(65,808002669,metta_other,['@params',[['@param',"Count"],['@param',"Form"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2182,2),line_char(2184,21))). -user:metta_file_buffer(66,808002670,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2185,3),line_char(2185,10))). -user:metta_file_buffer(66,808002670,string,"Results of Form after ignoring the first Count results that are generated.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2185,11),line_char(2185,87))). -user:metta_file_buffer(65,808002670,metta_other,['@return',"Results of Form after ignoring the first Count results that are generated."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2185,2),line_char(2185,88))). -user:metta_file_buffer(64,808002670,metta_other,['@doc','offset!',['@desc',"Executes Form ignoring the first Count results. Results are returned as soon as they become available."],['@params',[['@param',"Count"],['@param',"Form"]]],['@return',"Results of Form after ignoring the first Count results that are generated."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2180,0),line_char(2185,89))). -user:metta_file_buffer(65,809002671,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2186,1),line_char(2186,2))). -user:metta_file_buffer(65,809002671,constant,'offset!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2186,3),line_char(2186,10))). -user:metta_file_buffer(66,809002672,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2186,12),line_char(2186,14))). -user:metta_file_buffer(66,809002672,constant,'Number',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2186,15),line_char(2186,21))). -user:metta_file_buffer(66,809002672,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2186,22),line_char(2186,26))). -user:metta_file_buffer(66,809002672,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2186,27),line_char(2186,31))). -user:metta_file_buffer(65,809002672,metta_other,[->,'Number','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2186,11),line_char(2186,32))). -user:metta_file_buffer(64,809002672,metta_typedecl,[:,'offset!',[->,'Number','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2186,0),line_char(2186,33))). -user:metta_file_buffer(65,810002673,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2188,1),line_char(2188,3))). -user:metta_file_buffer(65,810002673,constant,'call!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2188,4),line_char(2188,9))). -user:metta_file_buffer(65,810002673,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2188,10),line_char(2188,18))). -user:metta_file_buffer(64,810002673,metta_other,[iz,'call!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2188,0),line_char(2188,19))). -user:metta_file_buffer(65,811002674,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2189,1),line_char(2189,5))). -user:metta_file_buffer(65,811002674,constant,'call!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2189,6),line_char(2189,11))). -user:metta_file_buffer(66,811002675,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2190,3),line_char(2190,8))). -user:metta_file_buffer(66,811002675,string,"Trampolines to Prolog's call. Only works when the predicate and each arg are provided separately. e.g. !(call! ls /) will print the root directory but !(call! ls(/)) will fail.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2190,9),line_char(2190,187))). -user:metta_file_buffer(65,811002675,metta_other,['@desc',"Trampolines to Prolog's call. Only works when the predicate and each arg are provided separately. e.g. !(call! ls /) will print the root directory but !(call! ls(/)) will fail."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2190,2),line_char(2190,188))). -user:metta_file_buffer(66,811002676,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2191,3),line_char(2191,10))). -user:metta_file_buffer(68,811002678,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2192,5),line_char(2192,11))). -user:metta_file_buffer(68,811002678,string,"Form",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2192,12),line_char(2192,18))). -user:metta_file_buffer(67,811002678,metta_other,['@param',"Form"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2192,4),line_char(2192,19))). -user:metta_file_buffer(66,811002678,array,[['@param',"Form"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2191,11),line_char(2192,20))). -user:metta_file_buffer(65,811002678,metta_other,['@params',[['@param',"Form"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2191,2),line_char(2192,21))). -user:metta_file_buffer(66,811002679,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2193,3),line_char(2193,10))). -user:metta_file_buffer(66,811002679,string,"True if the call succeeds, False otherwise.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2193,11),line_char(2193,56))). -user:metta_file_buffer(65,811002679,metta_other,['@return',"True if the call succeeds, False otherwise."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2193,2),line_char(2193,57))). -user:metta_file_buffer(64,811002679,metta_other,['@doc','call!',['@desc',"Trampolines to Prolog's call. Only works when the predicate and each arg are provided separately. e.g. !(call! ls /) will print the root directory but !(call! ls(/)) will fail."],['@params',[['@param',"Form"]]],['@return',"True if the call succeeds, False otherwise."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2189,0),line_char(2193,58))). -user:metta_file_buffer(65,812002680,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2194,1),line_char(2194,2))). -user:metta_file_buffer(65,812002680,constant,'call!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2194,3),line_char(2194,8))). -user:metta_file_buffer(66,812002681,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2194,10),line_char(2194,12))). -user:metta_file_buffer(66,812002681,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2194,13),line_char(2194,17))). -user:metta_file_buffer(66,812002681,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2194,18),line_char(2194,22))). -user:metta_file_buffer(65,812002681,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2194,9),line_char(2194,23))). -user:metta_file_buffer(64,812002681,metta_typedecl,[:,'call!',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2194,0),line_char(2194,24))). -user:metta_file_buffer(65,813002682,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2196,1),line_char(2196,3))). -user:metta_file_buffer(65,813002682,constant,'call-p!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2196,4),line_char(2196,11))). -user:metta_file_buffer(65,813002682,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2196,12),line_char(2196,20))). -user:metta_file_buffer(64,813002682,metta_other,[iz,'call-p!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2196,0),line_char(2196,21))). -user:metta_file_buffer(65,814002683,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2197,1),line_char(2197,5))). -user:metta_file_buffer(65,814002683,constant,'call-p!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2197,6),line_char(2197,13))). -user:metta_file_buffer(66,814002684,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2198,3),line_char(2198,8))). -user:metta_file_buffer(66,814002684,string,"Like call-fn! except it does not append the called term with a return arg.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2198,9),line_char(2198,85))). -user:metta_file_buffer(65,814002684,metta_other,['@desc',"Like call-fn! except it does not append the called term with a return arg."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2198,2),line_char(2198,86))). -user:metta_file_buffer(66,814002685,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2199,3),line_char(2199,10))). -user:metta_file_buffer(68,814002687,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2200,5),line_char(2200,11))). -user:metta_file_buffer(68,814002687,string,"Form",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2200,12),line_char(2200,18))). -user:metta_file_buffer(67,814002687,metta_other,['@param',"Form"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2200,4),line_char(2200,19))). -user:metta_file_buffer(66,814002687,array,[['@param',"Form"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2199,11),line_char(2200,20))). -user:metta_file_buffer(65,814002687,metta_other,['@params',[['@param',"Form"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2199,2),line_char(2200,21))). -user:metta_file_buffer(66,814002688,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2201,3),line_char(2201,10))). -user:metta_file_buffer(66,814002688,string,"True if the call succeeds, False otherwise.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2201,11),line_char(2201,56))). -user:metta_file_buffer(65,814002688,metta_other,['@return',"True if the call succeeds, False otherwise."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2201,2),line_char(2201,57))). -user:metta_file_buffer(64,814002688,metta_other,['@doc','call-p!',['@desc',"Like call-fn! except it does not append the called term with a return arg."],['@params',[['@param',"Form"]]],['@return',"True if the call succeeds, False otherwise."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2197,0),line_char(2201,58))). -user:metta_file_buffer(65,815002689,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2202,1),line_char(2202,2))). -user:metta_file_buffer(65,815002689,constant,'call-p!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2202,3),line_char(2202,10))). -user:metta_file_buffer(66,815002690,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2202,12),line_char(2202,14))). -user:metta_file_buffer(66,815002690,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2202,15),line_char(2202,19))). -user:metta_file_buffer(66,815002690,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2202,20),line_char(2202,24))). -user:metta_file_buffer(65,815002690,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2202,11),line_char(2202,25))). -user:metta_file_buffer(64,815002690,metta_typedecl,[:,'call-p!',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2202,0),line_char(2202,26))). -user:metta_file_buffer(65,816002691,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2204,1),line_char(2204,3))). -user:metta_file_buffer(65,816002691,constant,'call-fn!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2204,4),line_char(2204,12))). -user:metta_file_buffer(65,816002691,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2204,13),line_char(2204,21))). -user:metta_file_buffer(64,816002691,metta_other,[iz,'call-fn!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2204,0),line_char(2204,22))). -user:metta_file_buffer(65,817002692,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2205,1),line_char(2205,5))). -user:metta_file_buffer(65,817002692,constant,'call-fn!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2205,6),line_char(2205,14))). -user:metta_file_buffer(66,817002693,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2206,3),line_char(2206,8))). -user:metta_file_buffer(66,817002693,string,"Trampolines to Prolog's call after appending the return argument. Each arg are provided separately. e.g. !(call-fn! length (1 2 3)) will return 3.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2206,9),line_char(2206,158))). -user:metta_file_buffer(65,817002693,metta_other,['@desc',"Trampolines to Prolog's call after appending the return argument. Each arg are provided separately. e.g. !(call-fn! length (1 2 3)) will return 3."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2206,2),line_char(2206,159))). -user:metta_file_buffer(66,817002694,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2207,3),line_char(2207,10))). -user:metta_file_buffer(68,817002696,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2208,5),line_char(2208,11))). -user:metta_file_buffer(68,817002696,string,"Form",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2208,12),line_char(2208,18))). -user:metta_file_buffer(67,817002696,metta_other,['@param',"Form"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2208,4),line_char(2208,19))). -user:metta_file_buffer(66,817002696,array,[['@param',"Form"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2207,11),line_char(2208,20))). -user:metta_file_buffer(65,817002696,metta_other,['@params',[['@param',"Form"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2207,2),line_char(2208,21))). -user:metta_file_buffer(66,817002697,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2209,3),line_char(2209,10))). -user:metta_file_buffer(66,817002697,string,"appends a return argument to a form and calls it",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2209,11),line_char(2209,61))). -user:metta_file_buffer(65,817002697,metta_other,['@return',"appends a return argument to a form and calls it"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2209,2),line_char(2209,62))). -user:metta_file_buffer(64,817002697,metta_other,['@doc','call-fn!',['@desc',"Trampolines to Prolog's call after appending the return argument. Each arg are provided separately. e.g. !(call-fn! length (1 2 3)) will return 3."],['@params',[['@param',"Form"]]],['@return',"appends a return argument to a form and calls it"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2205,0),line_char(2209,63))). -user:metta_file_buffer(65,818002698,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2210,1),line_char(2210,2))). -user:metta_file_buffer(65,818002698,constant,'call-fn!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2210,3),line_char(2210,11))). -user:metta_file_buffer(66,818002699,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2210,13),line_char(2210,15))). -user:metta_file_buffer(66,818002699,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2210,16),line_char(2210,20))). -user:metta_file_buffer(66,818002699,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2210,21),line_char(2210,25))). -user:metta_file_buffer(65,818002699,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2210,12),line_char(2210,26))). -user:metta_file_buffer(64,818002699,metta_typedecl,[:,'call-fn!',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2210,0),line_char(2210,27))). -user:metta_file_buffer(65,819002700,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2212,1),line_char(2212,3))). -user:metta_file_buffer(65,819002700,constant,'call-string!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2212,4),line_char(2212,16))). -user:metta_file_buffer(65,819002700,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2212,17),line_char(2212,25))). -user:metta_file_buffer(64,819002700,metta_other,[iz,'call-string!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2212,0),line_char(2212,26))). -user:metta_file_buffer(65,820002701,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2213,1),line_char(2213,5))). -user:metta_file_buffer(65,820002701,constant,'call-string!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2213,6),line_char(2213,18))). -user:metta_file_buffer(66,820002702,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2214,3),line_char(2214,8))). -user:metta_file_buffer(66,820002702,string,"Executes String as Prolog code. For example, (call-string! \"member(1,[1,2,3])\") returns [()] while (call-string! \"member(4,[1,2,3])\") returns []. (call-string! \"member(X,[1,2,3])\") returns [(1), (2), (3)].",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2214,9),line_char(2214,222))). -user:metta_file_buffer(65,820002702,metta_other,['@desc',"Executes String as Prolog code. For example, (call-string! \"member(1,[1,2,3])\") returns [()] while (call-string! \"member(4,[1,2,3])\") returns []. (call-string! \"member(X,[1,2,3])\") returns [(1), (2), (3)]."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2214,2),line_char(2214,223))). -user:metta_file_buffer(66,820002703,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2215,3),line_char(2215,10))). -user:metta_file_buffer(68,820002705,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2216,5),line_char(2216,11))). -user:metta_file_buffer(68,820002705,string,"PrologSrc",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2216,12),line_char(2216,23))). -user:metta_file_buffer(67,820002705,metta_other,['@param',"PrologSrc"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2216,4),line_char(2216,24))). -user:metta_file_buffer(66,820002705,array,[['@param',"PrologSrc"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2215,11),line_char(2216,25))). -user:metta_file_buffer(65,820002705,metta_other,['@params',[['@param',"PrologSrc"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2215,2),line_char(2216,26))). -user:metta_file_buffer(66,820002706,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2217,3),line_char(2217,10))). -user:metta_file_buffer(66,820002706,string,"A list of the binding values. If there are no bindings but the Prolog query is True, returns the empty list.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2217,11),line_char(2217,121))). -user:metta_file_buffer(65,820002706,metta_other,['@return',"A list of the binding values. If there are no bindings but the Prolog query is True, returns the empty list."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2217,2),line_char(2217,122))). -user:metta_file_buffer(64,820002706,metta_other,['@doc','call-string!',['@desc',"Executes String as Prolog code. For example, (call-string! \"member(1,[1,2,3])\") returns [()] while (call-string! \"member(4,[1,2,3])\") returns []. (call-string! \"member(X,[1,2,3])\") returns [(1), (2), (3)]."],['@params',[['@param',"PrologSrc"]]],['@return',"A list of the binding values. If there are no bindings but the Prolog query is True, returns the empty list."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2213,0),line_char(2217,123))). -user:metta_file_buffer(65,821002707,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2218,1),line_char(2218,2))). -user:metta_file_buffer(65,821002707,constant,'call-string!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2218,3),line_char(2218,15))). -user:metta_file_buffer(66,821002708,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2218,17),line_char(2218,19))). -user:metta_file_buffer(66,821002708,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2218,20),line_char(2218,26))). -user:metta_file_buffer(66,821002708,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2218,27),line_char(2218,31))). -user:metta_file_buffer(65,821002708,metta_other,[->,'String','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2218,16),line_char(2218,32))). -user:metta_file_buffer(64,821002708,metta_typedecl,[:,'call-string!',[->,'String','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2218,0),line_char(2218,33))). -user:metta_file_buffer(65,822002709,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2220,1),line_char(2220,3))). -user:metta_file_buffer(65,822002709,constant,'call-cleanup!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2220,4),line_char(2220,17))). -user:metta_file_buffer(65,822002709,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2220,18),line_char(2220,26))). -user:metta_file_buffer(64,822002709,metta_other,[iz,'call-cleanup!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2220,0),line_char(2220,27))). -user:metta_file_buffer(65,823002710,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2221,1),line_char(2221,5))). -user:metta_file_buffer(65,823002710,constant,'call-cleanup!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2221,6),line_char(2221,19))). -user:metta_file_buffer(66,823002711,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2222,3),line_char(2222,8))). -user:metta_file_buffer(66,823002711,string,"Same as (setup-call-cleanup! true Form Cleanup). setup-call-cleanup! is recommended instead if Cleanup is intended to undo prior side-effects - place those side-effects in Setup.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2222,9),line_char(2222,189))). -user:metta_file_buffer(65,823002711,metta_other,['@desc',"Same as (setup-call-cleanup! true Form Cleanup). setup-call-cleanup! is recommended instead if Cleanup is intended to undo prior side-effects - place those side-effects in Setup."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2222,2),line_char(2222,190))). -user:metta_file_buffer(66,823002712,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2223,3),line_char(2223,10))). -user:metta_file_buffer(68,823002714,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2224,5),line_char(2224,11))). -user:metta_file_buffer(68,823002714,string,"Form",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2224,12),line_char(2224,18))). -user:metta_file_buffer(67,823002714,metta_other,['@param',"Form"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2224,4),line_char(2224,19))). -user:metta_file_buffer(68,823002715,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2225,5),line_char(2225,11))). -user:metta_file_buffer(68,823002715,string,"Cleanup",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2225,12),line_char(2225,21))). -user:metta_file_buffer(67,823002715,metta_other,['@param',"Cleanup"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2225,4),line_char(2225,22))). -user:metta_file_buffer(66,823002715,array,[['@param',"Form"],['@param',"Cleanup"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2223,11),line_char(2225,23))). -user:metta_file_buffer(65,823002715,metta_other,['@params',[['@param',"Form"],['@param',"Cleanup"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2223,2),line_char(2225,24))). -user:metta_file_buffer(66,823002716,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2226,3),line_char(2226,10))). -user:metta_file_buffer(66,823002716,string,"Result of Form.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2226,11),line_char(2226,28))). -user:metta_file_buffer(65,823002716,metta_other,['@return',"Result of Form."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2226,2),line_char(2226,29))). -user:metta_file_buffer(64,823002716,metta_other,['@doc','call-cleanup!',['@desc',"Same as (setup-call-cleanup! true Form Cleanup). setup-call-cleanup! is recommended instead if Cleanup is intended to undo prior side-effects - place those side-effects in Setup."],['@params',[['@param',"Form"],['@param',"Cleanup"]]],['@return',"Result of Form."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2221,0),line_char(2226,30))). -user:metta_file_buffer(65,824002717,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2227,1),line_char(2227,2))). -user:metta_file_buffer(65,824002717,constant,'call-cleanup!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2227,3),line_char(2227,16))). -user:metta_file_buffer(66,824002718,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2227,18),line_char(2227,20))). -user:metta_file_buffer(66,824002718,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2227,21),line_char(2227,25))). -user:metta_file_buffer(66,824002718,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2227,26),line_char(2227,30))). -user:metta_file_buffer(66,824002718,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2227,31),line_char(2227,35))). -user:metta_file_buffer(65,824002718,metta_other,[->,'Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2227,17),line_char(2227,36))). -user:metta_file_buffer(64,824002718,metta_typedecl,[:,'call-cleanup!',[->,'Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2227,0),line_char(2227,37))). -user:metta_file_buffer(65,825002719,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2229,1),line_char(2229,3))). -user:metta_file_buffer(65,825002719,constant,'setup-call-cleanup!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2229,4),line_char(2229,23))). -user:metta_file_buffer(65,825002719,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2229,24),line_char(2229,32))). -user:metta_file_buffer(64,825002719,metta_other,[iz,'setup-call-cleanup!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2229,0),line_char(2229,33))). -user:metta_file_buffer(65,826002720,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2230,1),line_char(2230,5))). -user:metta_file_buffer(65,826002720,constant,'setup-call-cleanup!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2230,6),line_char(2230,25))). -user:metta_file_buffer(66,826002721,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2231,3),line_char(2231,8))). -user:metta_file_buffer(66,826002721,string,"Executes Setup, then Form, then finally Cleanup. Setup is protected from interrupts (e.g. max-time!). In most uses, Setup will perform temporary side-effects required by Form that are finally undone by Cleanup. Cleanup is run even if Form raises an exception. For each result of Setup, Form is run to completion, then Cleanup is run.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2231,9),line_char(2231,344))). -user:metta_file_buffer(65,826002721,metta_other,['@desc',"Executes Setup, then Form, then finally Cleanup. Setup is protected from interrupts (e.g. max-time!). In most uses, Setup will perform temporary side-effects required by Form that are finally undone by Cleanup. Cleanup is run even if Form raises an exception. For each result of Setup, Form is run to completion, then Cleanup is run."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2231,2),line_char(2231,345))). -user:metta_file_buffer(66,826002722,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2232,3),line_char(2232,10))). -user:metta_file_buffer(68,826002724,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2233,5),line_char(2233,11))). -user:metta_file_buffer(68,826002724,string,"Setup",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2233,12),line_char(2233,19))). -user:metta_file_buffer(67,826002724,metta_other,['@param',"Setup"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2233,4),line_char(2233,20))). -user:metta_file_buffer(68,826002725,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2234,5),line_char(2234,11))). -user:metta_file_buffer(68,826002725,string,"Form",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2234,12),line_char(2234,18))). -user:metta_file_buffer(67,826002725,metta_other,['@param',"Form"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2234,4),line_char(2234,19))). -user:metta_file_buffer(68,826002726,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2235,5),line_char(2235,11))). -user:metta_file_buffer(68,826002726,string,"Cleanup",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2235,12),line_char(2235,21))). -user:metta_file_buffer(67,826002726,metta_other,['@param',"Cleanup"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2235,4),line_char(2235,22))). -user:metta_file_buffer(66,826002726,array,[['@param',"Setup"],['@param',"Form"],['@param',"Cleanup"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2232,11),line_char(2235,23))). -user:metta_file_buffer(65,826002726,metta_other,['@params',[['@param',"Setup"],['@param',"Form"],['@param',"Cleanup"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2232,2),line_char(2235,24))). -user:metta_file_buffer(66,826002727,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2236,3),line_char(2236,10))). -user:metta_file_buffer(66,826002727,string,"Result of Form.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2236,11),line_char(2236,28))). -user:metta_file_buffer(65,826002727,metta_other,['@return',"Result of Form."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2236,2),line_char(2236,29))). -user:metta_file_buffer(64,826002727,metta_other,['@doc','setup-call-cleanup!',['@desc',"Executes Setup, then Form, then finally Cleanup. Setup is protected from interrupts (e.g. max-time!). In most uses, Setup will perform temporary side-effects required by Form that are finally undone by Cleanup. Cleanup is run even if Form raises an exception. For each result of Setup, Form is run to completion, then Cleanup is run."],['@params',[['@param',"Setup"],['@param',"Form"],['@param',"Cleanup"]]],['@return',"Result of Form."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2230,0),line_char(2236,30))). -user:metta_file_buffer(65,827002728,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2237,1),line_char(2237,2))). -user:metta_file_buffer(65,827002728,constant,'setup-call-cleanup!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2237,3),line_char(2237,22))). -user:metta_file_buffer(66,827002729,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2237,24),line_char(2237,26))). -user:metta_file_buffer(66,827002729,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2237,27),line_char(2237,31))). -user:metta_file_buffer(66,827002729,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2237,32),line_char(2237,36))). -user:metta_file_buffer(66,827002729,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2237,37),line_char(2237,41))). -user:metta_file_buffer(66,827002729,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2237,42),line_char(2237,46))). -user:metta_file_buffer(65,827002729,metta_other,[->,'Atom','Atom','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2237,23),line_char(2237,47))). -user:metta_file_buffer(64,827002729,metta_typedecl,[:,'setup-call-cleanup!',[->,'Atom','Atom','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2237,0),line_char(2237,48))). -user:metta_file_buffer(65,828002730,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2239,1),line_char(2239,3))). -user:metta_file_buffer(65,828002730,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2239,4),line_char(2239,19))). -user:metta_file_buffer(65,828002730,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2239,20),line_char(2239,28))). -user:metta_file_buffer(64,828002730,metta_other,[iz,'predicate-arity','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2239,0),line_char(2239,29))). -user:metta_file_buffer(65,829002731,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2240,1),line_char(2240,5))). -user:metta_file_buffer(65,829002731,constant,'predicate-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2240,6),line_char(2240,21))). -user:metta_file_buffer(66,829002732,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2241,3),line_char(2241,8))). -user:metta_file_buffer(66,829002732,string,"Returns the arity of Function's predicate form, i.e. the function-arity + 1. (The additional argument being the function's result as an argument to the predicate.)",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2241,9),line_char(2241,174))). -user:metta_file_buffer(65,829002732,metta_other,['@desc',"Returns the arity of Function's predicate form, i.e. the function-arity + 1. (The additional argument being the function's result as an argument to the predicate.)"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2241,2),line_char(2241,175))). -user:metta_file_buffer(66,829002733,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2242,3),line_char(2242,10))). -user:metta_file_buffer(68,829002735,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2243,5),line_char(2243,11))). -user:metta_file_buffer(68,829002735,string,"Function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2243,12),line_char(2243,22))). -user:metta_file_buffer(67,829002735,metta_other,['@param',"Function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2243,4),line_char(2243,23))). -user:metta_file_buffer(66,829002735,array,[['@param',"Function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2242,11),line_char(2243,24))). -user:metta_file_buffer(65,829002735,metta_other,['@params',[['@param',"Function"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2242,2),line_char(2243,25))). -user:metta_file_buffer(66,829002736,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2244,3),line_char(2244,10))). -user:metta_file_buffer(66,829002736,string,"Arity of Function's predicate form.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2244,11),line_char(2244,48))). -user:metta_file_buffer(65,829002736,metta_other,['@return',"Arity of Function's predicate form."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2244,2),line_char(2244,49))). -user:metta_file_buffer(64,829002736,metta_other,['@doc','predicate-arity',['@desc',"Returns the arity of Function's predicate form, i.e. the function-arity + 1. (The additional argument being the function's result as an argument to the predicate.)"],['@params',[['@param',"Function"]]],['@return',"Arity of Function's predicate form."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2240,0),line_char(2244,50))). -user:metta_file_buffer(65,830002737,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2246,1),line_char(2246,3))). -user:metta_file_buffer(65,830002737,constant,'function-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2246,4),line_char(2246,18))). -user:metta_file_buffer(65,830002737,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2246,19),line_char(2246,27))). -user:metta_file_buffer(64,830002737,metta_other,[iz,'function-arity','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2246,0),line_char(2246,28))). -user:metta_file_buffer(65,831002738,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2247,1),line_char(2247,5))). -user:metta_file_buffer(65,831002738,constant,'function-arity',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2247,6),line_char(2247,20))). -user:metta_file_buffer(66,831002739,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2248,3),line_char(2248,8))). -user:metta_file_buffer(66,831002739,string,"Returns the arity of Function.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2248,9),line_char(2248,41))). -user:metta_file_buffer(65,831002739,metta_other,['@desc',"Returns the arity of Function."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2248,2),line_char(2248,42))). -user:metta_file_buffer(66,831002740,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2249,3),line_char(2249,10))). -user:metta_file_buffer(68,831002742,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2250,5),line_char(2250,11))). -user:metta_file_buffer(68,831002742,string,"Function",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2250,12),line_char(2250,22))). -user:metta_file_buffer(67,831002742,metta_other,['@param',"Function"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2250,4),line_char(2250,23))). -user:metta_file_buffer(66,831002742,array,[['@param',"Function"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2249,11),line_char(2250,24))). -user:metta_file_buffer(65,831002742,metta_other,['@params',[['@param',"Function"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2249,2),line_char(2250,25))). -user:metta_file_buffer(66,831002743,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2251,3),line_char(2251,10))). -user:metta_file_buffer(66,831002743,string,"Arity of Function.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2251,11),line_char(2251,31))). -user:metta_file_buffer(65,831002743,metta_other,['@return',"Arity of Function."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2251,2),line_char(2251,32))). -user:metta_file_buffer(64,831002743,metta_other,['@doc','function-arity',['@desc',"Returns the arity of Function."],['@params',[['@param',"Function"]]],['@return',"Arity of Function."]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2247,0),line_char(2251,33))). -user:metta_file_buffer(65,832002744,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2253,1),line_char(2253,3))). -user:metta_file_buffer(65,832002744,constant,'open!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2253,4),line_char(2253,9))). -user:metta_file_buffer(65,832002744,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2253,10),line_char(2253,18))). -user:metta_file_buffer(64,832002744,metta_other,[iz,'open!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2253,0),line_char(2253,19))). -user:metta_file_buffer(65,833002745,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2254,1),line_char(2254,5))). -user:metta_file_buffer(65,833002745,constant,'open!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2254,6),line_char(2254,11))). -user:metta_file_buffer(66,833002746,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2255,3),line_char(2255,8))). -user:metta_file_buffer(66,833002746,string,"Opens Filename as a stream under Mode. Mode is one of read, write, append, or update. Mode append opens the file for writing, positioning the file pointer at the end. Mode update opens the file for writing, positioning the file pointer at the beginning of the file without truncating the file.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2255,9),line_char(2255,304))). -user:metta_file_buffer(65,833002746,metta_other,['@desc',"Opens Filename as a stream under Mode. Mode is one of read, write, append, or update. Mode append opens the file for writing, positioning the file pointer at the end. Mode update opens the file for writing, positioning the file pointer at the beginning of the file without truncating the file."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2255,2),line_char(2255,305))). -user:metta_file_buffer(66,833002747,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2256,3),line_char(2256,10))). -user:metta_file_buffer(68,833002749,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2257,5),line_char(2257,11))). -user:metta_file_buffer(68,833002749,string,"Filename",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2257,12),line_char(2257,22))). -user:metta_file_buffer(67,833002749,metta_other,['@param',"Filename"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2257,4),line_char(2257,23))). -user:metta_file_buffer(68,833002750,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2258,5),line_char(2258,11))). -user:metta_file_buffer(68,833002750,string,"Mode",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2258,12),line_char(2258,18))). -user:metta_file_buffer(67,833002750,metta_other,['@param',"Mode"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2258,4),line_char(2258,19))). -user:metta_file_buffer(66,833002750,array,[['@param',"Filename"],['@param',"Mode"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2256,11),line_char(2258,20))). -user:metta_file_buffer(65,833002750,metta_other,['@params',[['@param',"Filename"],['@param',"Mode"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2256,2),line_char(2258,21))). -user:metta_file_buffer(66,833002751,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2259,3),line_char(2259,10))). -user:metta_file_buffer(66,833002751,string,"Stream",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2259,11),line_char(2259,19))). -user:metta_file_buffer(65,833002751,metta_other,['@return',"Stream"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2259,2),line_char(2259,20))). -user:metta_file_buffer(64,833002751,metta_other,['@doc','open!',['@desc',"Opens Filename as a stream under Mode. Mode is one of read, write, append, or update. Mode append opens the file for writing, positioning the file pointer at the end. Mode update opens the file for writing, positioning the file pointer at the beginning of the file without truncating the file."],['@params',[['@param',"Filename"],['@param',"Mode"]]],['@return',"Stream"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2254,0),line_char(2259,21))). -user:metta_file_buffer(65,834002752,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2260,1),line_char(2260,2))). -user:metta_file_buffer(65,834002752,constant,'open!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2260,3),line_char(2260,8))). -user:metta_file_buffer(66,834002753,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2260,10),line_char(2260,12))). -user:metta_file_buffer(66,834002753,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2260,13),line_char(2260,19))). -user:metta_file_buffer(66,834002753,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2260,20),line_char(2260,24))). -user:metta_file_buffer(66,834002753,constant,'Stream',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2260,25),line_char(2260,31))). -user:metta_file_buffer(65,834002753,metta_other,[->,'String','Atom','Stream'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2260,9),line_char(2260,32))). -user:metta_file_buffer(64,834002753,metta_typedecl,[:,'open!',[->,'String','Atom','Stream']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2260,0),line_char(2260,33))). -user:metta_file_buffer(65,835002754,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2262,1),line_char(2262,3))). -user:metta_file_buffer(65,835002754,constant,'close!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2262,4),line_char(2262,10))). -user:metta_file_buffer(65,835002754,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2262,11),line_char(2262,19))). -user:metta_file_buffer(64,835002754,metta_other,[iz,'close!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2262,0),line_char(2262,20))). -user:metta_file_buffer(65,836002755,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2263,1),line_char(2263,5))). -user:metta_file_buffer(65,836002755,constant,'close!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2263,6),line_char(2263,12))). -user:metta_file_buffer(66,836002756,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2264,3),line_char(2264,8))). -user:metta_file_buffer(66,836002756,string,"Closes Steam, returning True on success.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2264,9),line_char(2264,51))). -user:metta_file_buffer(65,836002756,metta_other,['@desc',"Closes Steam, returning True on success."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2264,2),line_char(2264,52))). -user:metta_file_buffer(66,836002757,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2265,3),line_char(2265,10))). -user:metta_file_buffer(68,836002759,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2266,5),line_char(2266,11))). -user:metta_file_buffer(68,836002759,string,"Stream",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2266,12),line_char(2266,20))). -user:metta_file_buffer(67,836002759,metta_other,['@param',"Stream"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2266,4),line_char(2266,21))). -user:metta_file_buffer(66,836002759,array,[['@param',"Stream"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2265,11),line_char(2266,22))). -user:metta_file_buffer(65,836002759,metta_other,['@params',[['@param',"Stream"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2265,2),line_char(2266,23))). -user:metta_file_buffer(66,836002760,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2267,3),line_char(2267,10))). -user:metta_file_buffer(66,836002760,string,"Boolean",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2267,11),line_char(2267,20))). -user:metta_file_buffer(65,836002760,metta_other,['@return',"Boolean"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2267,2),line_char(2267,21))). -user:metta_file_buffer(64,836002760,metta_other,['@doc','close!',['@desc',"Closes Steam, returning True on success."],['@params',[['@param',"Stream"]]],['@return',"Boolean"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2263,0),line_char(2267,22))). -user:metta_file_buffer(65,837002761,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2268,1),line_char(2268,2))). -user:metta_file_buffer(65,837002761,constant,'close!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2268,3),line_char(2268,9))). -user:metta_file_buffer(66,837002762,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2268,11),line_char(2268,13))). -user:metta_file_buffer(66,837002762,constant,'Stream',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2268,14),line_char(2268,20))). -user:metta_file_buffer(66,837002762,constant,'Boolean',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2268,21),line_char(2268,28))). -user:metta_file_buffer(65,837002762,metta_other,[->,'Stream','Boolean'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2268,10),line_char(2268,29))). -user:metta_file_buffer(64,837002762,metta_typedecl,[:,'close!',[->,'Stream','Boolean']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2268,0),line_char(2268,30))). -user:metta_file_buffer(65,838002763,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2270,1),line_char(2270,3))). -user:metta_file_buffer(65,838002763,constant,'with-output-to!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2270,4),line_char(2270,19))). -user:metta_file_buffer(65,838002763,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2270,20),line_char(2270,28))). -user:metta_file_buffer(64,838002763,metta_other,[iz,'with-output-to!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2270,0),line_char(2270,29))). -user:metta_file_buffer(65,839002764,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2271,1),line_char(2271,5))). -user:metta_file_buffer(65,839002764,constant,'with-output-to!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2271,6),line_char(2271,21))). -user:metta_file_buffer(66,839002765,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2272,3),line_char(2272,8))). -user:metta_file_buffer(66,839002765,string,"Evaluates expression with all outupt (e.g. from print) redirected to Stream. See also open! and close!.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2272,9),line_char(2272,114))). -user:metta_file_buffer(65,839002765,metta_other,['@desc',"Evaluates expression with all outupt (e.g. from print) redirected to Stream. See also open! and close!."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2272,2),line_char(2272,115))). -user:metta_file_buffer(66,839002766,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2273,3),line_char(2273,10))). -user:metta_file_buffer(68,839002768,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2274,5),line_char(2274,11))). -user:metta_file_buffer(68,839002768,string,"Stream",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2274,12),line_char(2274,20))). -user:metta_file_buffer(67,839002768,metta_other,['@param',"Stream"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2274,4),line_char(2274,21))). -user:metta_file_buffer(68,839002769,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2275,5),line_char(2275,11))). -user:metta_file_buffer(68,839002769,string,"Expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2275,12),line_char(2275,24))). -user:metta_file_buffer(67,839002769,metta_other,['@param',"Expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2275,4),line_char(2275,25))). -user:metta_file_buffer(66,839002769,array,[['@param',"Stream"],['@param',"Expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2273,11),line_char(2275,26))). -user:metta_file_buffer(65,839002769,metta_other,['@params',[['@param',"Stream"],['@param',"Expression"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2273,2),line_char(2275,27))). -user:metta_file_buffer(66,839002770,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2276,3),line_char(2276,10))). -user:metta_file_buffer(66,839002770,string,"Result of Expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2276,11),line_char(2276,33))). -user:metta_file_buffer(65,839002770,metta_other,['@return',"Result of Expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2276,2),line_char(2276,34))). -user:metta_file_buffer(64,839002770,metta_other,['@doc','with-output-to!',['@desc',"Evaluates expression with all outupt (e.g. from print) redirected to Stream. See also open! and close!."],['@params',[['@param',"Stream"],['@param',"Expression"]]],['@return',"Result of Expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2271,0),line_char(2276,35))). -user:metta_file_buffer(65,840002771,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2277,1),line_char(2277,2))). -user:metta_file_buffer(65,840002771,constant,'with-output-to!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2277,3),line_char(2277,18))). -user:metta_file_buffer(66,840002772,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2277,20),line_char(2277,22))). -user:metta_file_buffer(66,840002772,constant,'Stream',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2277,23),line_char(2277,29))). -user:metta_file_buffer(66,840002772,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2277,30),line_char(2277,40))). -user:metta_file_buffer(66,840002772,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2277,41),line_char(2277,45))). -user:metta_file_buffer(65,840002772,metta_other,[->,'Stream','Expression','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2277,19),line_char(2277,46))). -user:metta_file_buffer(64,840002772,metta_typedecl,[:,'with-output-to!',[->,'Stream','Expression','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2277,0),line_char(2277,47))). -user:metta_file_buffer(65,841002773,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2279,1),line_char(2279,3))). -user:metta_file_buffer(65,841002773,constant,'load-file!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2279,4),line_char(2279,14))). -user:metta_file_buffer(65,841002773,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2279,15),line_char(2279,23))). -user:metta_file_buffer(64,841002773,metta_other,[iz,'load-file!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2279,0),line_char(2279,24))). -user:metta_file_buffer(65,842002774,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2280,1),line_char(2280,5))). -user:metta_file_buffer(65,842002774,constant,'load-file!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2280,6),line_char(2280,16))). -user:metta_file_buffer(66,842002775,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2281,3),line_char(2281,8))). -user:metta_file_buffer(66,842002775,string,"Loads the contents of Filename into Space, returning () if successful. Can load Python code (.py) or MeTTa (.metta); if ambiguous, assumes MeTTa. Like import! but favors MeTTa over Python when the file type is ambiguous.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2281,9),line_char(2281,231))). -user:metta_file_buffer(65,842002775,metta_other,['@desc',"Loads the contents of Filename into Space, returning () if successful. Can load Python code (.py) or MeTTa (.metta); if ambiguous, assumes MeTTa. Like import! but favors MeTTa over Python when the file type is ambiguous."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2281,2),line_char(2281,232))). -user:metta_file_buffer(66,842002776,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2282,3),line_char(2282,10))). -user:metta_file_buffer(68,842002778,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2283,5),line_char(2283,11))). -user:metta_file_buffer(68,842002778,string,"Space",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2283,12),line_char(2283,19))). -user:metta_file_buffer(67,842002778,metta_other,['@param',"Space"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2283,4),line_char(2283,20))). -user:metta_file_buffer(68,842002779,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2284,5),line_char(2284,11))). -user:metta_file_buffer(68,842002779,string,"Filename",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2284,12),line_char(2284,22))). -user:metta_file_buffer(67,842002779,metta_other,['@param',"Filename"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2284,4),line_char(2284,23))). -user:metta_file_buffer(66,842002779,array,[['@param',"Space"],['@param',"Filename"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2282,11),line_char(2284,24))). -user:metta_file_buffer(65,842002779,metta_other,['@params',[['@param',"Space"],['@param',"Filename"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2282,2),line_char(2284,25))). -user:metta_file_buffer(66,842002780,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2285,3),line_char(2285,10))). -user:metta_file_buffer(66,842002780,string,"Expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2285,11),line_char(2285,23))). -user:metta_file_buffer(65,842002780,metta_other,['@return',"Expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2285,2),line_char(2285,24))). -user:metta_file_buffer(64,842002780,metta_other,['@doc','load-file!',['@desc',"Loads the contents of Filename into Space, returning () if successful. Can load Python code (.py) or MeTTa (.metta); if ambiguous, assumes MeTTa. Like import! but favors MeTTa over Python when the file type is ambiguous."],['@params',[['@param',"Space"],['@param',"Filename"]]],['@return',"Expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2280,0),line_char(2285,25))). -user:metta_file_buffer(65,843002781,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2286,1),line_char(2286,2))). -user:metta_file_buffer(65,843002781,constant,'load-file!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2286,3),line_char(2286,13))). -user:metta_file_buffer(66,843002782,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2286,15),line_char(2286,17))). -user:metta_file_buffer(66,843002782,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2286,18),line_char(2286,42))). -user:metta_file_buffer(66,843002782,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2286,43),line_char(2286,49))). -user:metta_file_buffer(66,843002782,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2286,50),line_char(2286,60))). -user:metta_file_buffer(65,843002782,metta_other,[->,'hyperon::space::DynSpace','String','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2286,14),line_char(2286,61))). -user:metta_file_buffer(64,843002782,metta_typedecl,[:,'load-file!',[->,'hyperon::space::DynSpace','String','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2286,0),line_char(2286,62))). -user:metta_file_buffer(65,844002783,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2288,1),line_char(2288,3))). -user:metta_file_buffer(65,844002783,constant,'load-ascii',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2288,4),line_char(2288,14))). -user:metta_file_buffer(65,844002783,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2288,15),line_char(2288,20))). -user:metta_file_buffer(64,844002783,metta_other,[iz,'load-ascii','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2288,0),line_char(2288,21))). -user:metta_file_buffer(65,845002784,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2289,1),line_char(2289,5))). -user:metta_file_buffer(65,845002784,constant,'load-ascii',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2289,6),line_char(2289,16))). -user:metta_file_buffer(66,845002785,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2290,3),line_char(2290,8))). -user:metta_file_buffer(66,845002785,string,"Loads the contents of Filename into Space, returning () if successful. Assumes the file is an ASCII file. Works like include!.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2290,9),line_char(2290,137))). -user:metta_file_buffer(65,845002785,metta_other,['@desc',"Loads the contents of Filename into Space, returning () if successful. Assumes the file is an ASCII file. Works like include!."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2290,2),line_char(2290,138))). -user:metta_file_buffer(66,845002786,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2291,3),line_char(2291,10))). -user:metta_file_buffer(68,845002788,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2292,5),line_char(2292,11))). -user:metta_file_buffer(68,845002788,string,"Space",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2292,12),line_char(2292,19))). -user:metta_file_buffer(67,845002788,metta_other,['@param',"Space"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2292,4),line_char(2292,20))). -user:metta_file_buffer(68,845002789,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2293,5),line_char(2293,11))). -user:metta_file_buffer(68,845002789,string,"Filename",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2293,12),line_char(2293,22))). -user:metta_file_buffer(67,845002789,metta_other,['@param',"Filename"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2293,4),line_char(2293,23))). -user:metta_file_buffer(66,845002789,array,[['@param',"Space"],['@param',"Filename"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2291,11),line_char(2293,24))). -user:metta_file_buffer(65,845002789,metta_other,['@params',[['@param',"Space"],['@param',"Filename"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2291,2),line_char(2293,25))). -user:metta_file_buffer(66,845002790,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2294,3),line_char(2294,10))). -user:metta_file_buffer(66,845002790,string,"Expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2294,11),line_char(2294,23))). -user:metta_file_buffer(65,845002790,metta_other,['@return',"Expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2294,2),line_char(2294,24))). -user:metta_file_buffer(64,845002790,metta_other,['@doc','load-ascii',['@desc',"Loads the contents of Filename into Space, returning () if successful. Assumes the file is an ASCII file. Works like include!."],['@params',[['@param',"Space"],['@param',"Filename"]]],['@return',"Expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2289,0),line_char(2294,25))). -user:metta_file_buffer(65,846002791,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2295,1),line_char(2295,2))). -user:metta_file_buffer(65,846002791,constant,'load-ascii',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2295,3),line_char(2295,13))). -user:metta_file_buffer(66,846002792,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2295,15),line_char(2295,17))). -user:metta_file_buffer(66,846002792,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2295,18),line_char(2295,42))). -user:metta_file_buffer(66,846002792,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2295,43),line_char(2295,49))). -user:metta_file_buffer(66,846002792,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2295,50),line_char(2295,60))). -user:metta_file_buffer(65,846002792,metta_other,[->,'hyperon::space::DynSpace','String','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2295,14),line_char(2295,61))). -user:metta_file_buffer(64,846002792,metta_typedecl,[:,'load-ascii',[->,'hyperon::space::DynSpace','String','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2295,0),line_char(2295,62))). -user:metta_file_buffer(65,847002793,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2297,1),line_char(2297,3))). -user:metta_file_buffer(65,847002793,constant,'transfer!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2297,4),line_char(2297,13))). -user:metta_file_buffer(65,847002793,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2297,14),line_char(2297,19))). -user:metta_file_buffer(64,847002793,metta_other,[iz,'transfer!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2297,0),line_char(2297,20))). -user:metta_file_buffer(65,848002794,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2298,1),line_char(2298,5))). -user:metta_file_buffer(65,848002794,constant,'transfer!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2298,6),line_char(2298,15))). -user:metta_file_buffer(66,848002795,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2299,3),line_char(2299,8))). -user:metta_file_buffer(66,848002795,string,"Loads the contents of Filename into &self, as include. Returns () if successful, throws an exception otherwise.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2299,9),line_char(2299,122))). -user:metta_file_buffer(65,848002795,metta_other,['@desc',"Loads the contents of Filename into &self, as include. Returns () if successful, throws an exception otherwise."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2299,2),line_char(2299,123))). -user:metta_file_buffer(66,848002796,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2300,3),line_char(2300,10))). -user:metta_file_buffer(68,848002798,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2301,5),line_char(2301,11))). -user:metta_file_buffer(68,848002798,string,"Filename",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2301,12),line_char(2301,22))). -user:metta_file_buffer(67,848002798,metta_other,['@param',"Filename"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2301,4),line_char(2301,23))). -user:metta_file_buffer(66,848002798,array,[['@param',"Filename"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2300,11),line_char(2301,24))). -user:metta_file_buffer(65,848002798,metta_other,['@params',[['@param',"Filename"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2300,2),line_char(2301,25))). -user:metta_file_buffer(66,848002799,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2302,3),line_char(2302,10))). -user:metta_file_buffer(66,848002799,string,"Expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2302,11),line_char(2302,23))). -user:metta_file_buffer(65,848002799,metta_other,['@return',"Expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2302,2),line_char(2302,24))). -user:metta_file_buffer(64,848002799,metta_other,['@doc','transfer!',['@desc',"Loads the contents of Filename into &self, as include. Returns () if successful, throws an exception otherwise."],['@params',[['@param',"Filename"]]],['@return',"Expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2298,0),line_char(2302,25))). -user:metta_file_buffer(65,849002800,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2303,1),line_char(2303,2))). -user:metta_file_buffer(65,849002800,constant,'transfer!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2303,3),line_char(2303,12))). -user:metta_file_buffer(66,849002801,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2303,14),line_char(2303,16))). -user:metta_file_buffer(66,849002801,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2303,17),line_char(2303,23))). -user:metta_file_buffer(67,849002802,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2303,25),line_char(2303,27))). -user:metta_file_buffer(66,849002802,metta_other,[->],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2303,24),line_char(2303,28))). -user:metta_file_buffer(65,849002802,metta_other,[->,'String',[->]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2303,13),line_char(2303,29))). -user:metta_file_buffer(64,849002802,metta_typedecl,[:,'transfer!',[->,'String',[->]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2303,0),line_char(2303,30))). -user:metta_file_buffer(65,850002803,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2305,1),line_char(2305,3))). -user:metta_file_buffer(65,850002803,constant,'save-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2305,4),line_char(2305,15))). -user:metta_file_buffer(65,850002803,constant,'MeTTa',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2305,16),line_char(2305,21))). -user:metta_file_buffer(64,850002803,metta_other,[iz,'save-space!','MeTTa'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2305,0),line_char(2305,22))). -user:metta_file_buffer(65,851002804,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2306,1),line_char(2306,5))). -user:metta_file_buffer(65,851002804,constant,'save-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2306,6),line_char(2306,17))). -user:metta_file_buffer(66,851002805,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2307,3),line_char(2307,8))). -user:metta_file_buffer(66,851002805,string,"Writes the contents of Space into Filename, returning () if successful.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2307,9),line_char(2307,82))). -user:metta_file_buffer(65,851002805,metta_other,['@desc',"Writes the contents of Space into Filename, returning () if successful."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2307,2),line_char(2307,83))). -user:metta_file_buffer(66,851002806,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2308,3),line_char(2308,10))). -user:metta_file_buffer(68,851002808,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2309,5),line_char(2309,11))). -user:metta_file_buffer(68,851002808,string,"Space",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2309,12),line_char(2309,19))). -user:metta_file_buffer(67,851002808,metta_other,['@param',"Space"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2309,4),line_char(2309,20))). -user:metta_file_buffer(68,851002809,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2310,5),line_char(2310,11))). -user:metta_file_buffer(68,851002809,string,"Filename",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2310,12),line_char(2310,22))). -user:metta_file_buffer(67,851002809,metta_other,['@param',"Filename"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2310,4),line_char(2310,23))). -user:metta_file_buffer(66,851002809,array,[['@param',"Space"],['@param',"Filename"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2308,11),line_char(2310,24))). -user:metta_file_buffer(65,851002809,metta_other,['@params',[['@param',"Space"],['@param',"Filename"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2308,2),line_char(2310,25))). -user:metta_file_buffer(66,851002810,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2311,3),line_char(2311,10))). -user:metta_file_buffer(66,851002810,string,"Expression",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2311,11),line_char(2311,23))). -user:metta_file_buffer(65,851002810,metta_other,['@return',"Expression"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2311,2),line_char(2311,24))). -user:metta_file_buffer(64,851002810,metta_other,['@doc','save-space!',['@desc',"Writes the contents of Space into Filename, returning () if successful."],['@params',[['@param',"Space"],['@param',"Filename"]]],['@return',"Expression"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2306,0),line_char(2311,25))). -user:metta_file_buffer(65,852002811,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2312,1),line_char(2312,2))). -user:metta_file_buffer(65,852002811,constant,'save-space!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2312,3),line_char(2312,14))). -user:metta_file_buffer(66,852002812,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2312,16),line_char(2312,18))). -user:metta_file_buffer(66,852002812,constant,'hyperon::space::DynSpace',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2312,19),line_char(2312,43))). -user:metta_file_buffer(66,852002812,constant,'String',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2312,44),line_char(2312,50))). -user:metta_file_buffer(66,852002812,constant,'Expression',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2312,51),line_char(2312,61))). -user:metta_file_buffer(65,852002812,metta_other,[->,'hyperon::space::DynSpace','String','Expression'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2312,15),line_char(2312,62))). -user:metta_file_buffer(64,852002812,metta_typedecl,[:,'save-space!',[->,'hyperon::space::DynSpace','String','Expression']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2312,0),line_char(2312,63))). -user:metta_file_buffer(65,853002813,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2314,1),line_char(2314,3))). -user:metta_file_buffer(65,853002813,constant,'rtrace!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2314,4),line_char(2314,11))). -user:metta_file_buffer(65,853002813,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2314,12),line_char(2314,20))). -user:metta_file_buffer(64,853002813,metta_other,[iz,'rtrace!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2314,0),line_char(2314,21))). -user:metta_file_buffer(65,854002814,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2315,1),line_char(2315,5))). -user:metta_file_buffer(65,854002814,constant,'rtrace!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2315,6),line_char(2315,13))). -user:metta_file_buffer(66,854002815,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2316,3),line_char(2316,8))). -user:metta_file_buffer(66,854002815,string,"Fully evaluates input Atom, providing a complete trace of the evaluation.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2316,9),line_char(2316,84))). -user:metta_file_buffer(65,854002815,metta_other,['@desc',"Fully evaluates input Atom, providing a complete trace of the evaluation."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2316,2),line_char(2316,85))). -user:metta_file_buffer(66,854002816,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2317,3),line_char(2317,10))). -user:metta_file_buffer(68,854002818,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2318,5),line_char(2318,11))). -user:metta_file_buffer(68,854002818,string,"Atom to be evaluated",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2318,12),line_char(2318,34))). -user:metta_file_buffer(67,854002818,metta_other,['@param',"Atom to be evaluated"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2318,4),line_char(2318,35))). -user:metta_file_buffer(66,854002818,array,[['@param',"Atom to be evaluated"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2317,11),line_char(2318,36))). -user:metta_file_buffer(65,854002818,metta_other,['@params',[['@param',"Atom to be evaluated"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2317,2),line_char(2318,37))). -user:metta_file_buffer(66,854002819,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2319,3),line_char(2319,10))). -user:metta_file_buffer(66,854002819,string,"Result of evaluation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2319,11),line_char(2319,33))). -user:metta_file_buffer(65,854002819,metta_other,['@return',"Result of evaluation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2319,2),line_char(2319,34))). -user:metta_file_buffer(64,854002819,metta_other,['@doc','rtrace!',['@desc',"Fully evaluates input Atom, providing a complete trace of the evaluation."],['@params',[['@param',"Atom to be evaluated"]]],['@return',"Result of evaluation"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2315,0),line_char(2319,35))). -user:metta_file_buffer(65,855002820,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2320,1),line_char(2320,2))). -user:metta_file_buffer(65,855002820,constant,'rtrace!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2320,3),line_char(2320,10))). -user:metta_file_buffer(66,855002821,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2320,12),line_char(2320,14))). -user:metta_file_buffer(66,855002821,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2320,15),line_char(2320,19))). -user:metta_file_buffer(66,855002821,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2320,20),line_char(2320,24))). -user:metta_file_buffer(65,855002821,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2320,11),line_char(2320,25))). -user:metta_file_buffer(64,855002821,metta_typedecl,[:,'rtrace!',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2320,0),line_char(2320,26))). -user:metta_file_buffer(65,856002822,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2322,1),line_char(2322,3))). -user:metta_file_buffer(65,856002822,constant,rust,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2322,4),line_char(2322,8))). -user:metta_file_buffer(65,856002822,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2322,9),line_char(2322,17))). -user:metta_file_buffer(64,856002822,metta_other,[iz,rust,'MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2322,0),line_char(2322,18))). -user:metta_file_buffer(65,857002823,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2323,1),line_char(2323,5))). -user:metta_file_buffer(65,857002823,constant,rust,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2323,6),line_char(2323,10))). -user:metta_file_buffer(66,857002824,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2324,3),line_char(2324,8))). -user:metta_file_buffer(66,857002824,string,"Interface with the rust / Hyperon MeTTa implementation. Enters Atom into rust atomspace. If Atom is evaluated (i.e. by being of the form !), returns the result of evaluation. See also rust!.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2324,9),line_char(2324,207))). -user:metta_file_buffer(65,857002824,metta_other,['@desc',"Interface with the rust / Hyperon MeTTa implementation. Enters Atom into rust atomspace. If Atom is evaluated (i.e. by being of the form !), returns the result of evaluation. See also rust!."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2324,2),line_char(2324,208))). -user:metta_file_buffer(66,857002825,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2325,3),line_char(2325,10))). -user:metta_file_buffer(68,857002827,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2326,5),line_char(2326,11))). -user:metta_file_buffer(68,857002827,string,"Atom to be entered into the space",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2326,12),line_char(2326,47))). -user:metta_file_buffer(67,857002827,metta_other,['@param',"Atom to be entered into the space"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2326,4),line_char(2326,48))). -user:metta_file_buffer(66,857002827,array,[['@param',"Atom to be entered into the space"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2325,11),line_char(2326,49))). -user:metta_file_buffer(65,857002827,metta_other,['@params',[['@param',"Atom to be entered into the space"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2325,2),line_char(2326,50))). -user:metta_file_buffer(66,857002828,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2327,3),line_char(2327,10))). -user:metta_file_buffer(66,857002828,string,"Result of entering Atom into the space",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2327,11),line_char(2327,51))). -user:metta_file_buffer(65,857002828,metta_other,['@return',"Result of entering Atom into the space"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2327,2),line_char(2327,52))). -user:metta_file_buffer(64,857002828,metta_other,['@doc',rust,['@desc',"Interface with the rust / Hyperon MeTTa implementation. Enters Atom into rust atomspace. If Atom is evaluated (i.e. by being of the form !), returns the result of evaluation. See also rust!."],['@params',[['@param',"Atom to be entered into the space"]]],['@return',"Result of entering Atom into the space"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2323,0),line_char(2327,53))). -user:metta_file_buffer(65,858002829,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2328,1),line_char(2328,2))). -user:metta_file_buffer(65,858002829,constant,rust,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2328,3),line_char(2328,7))). -user:metta_file_buffer(66,858002830,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2328,9),line_char(2328,11))). -user:metta_file_buffer(66,858002830,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2328,12),line_char(2328,16))). -user:metta_file_buffer(66,858002830,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2328,17),line_char(2328,21))). -user:metta_file_buffer(65,858002830,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2328,8),line_char(2328,22))). -user:metta_file_buffer(64,858002830,metta_typedecl,[:,rust,[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2328,0),line_char(2328,23))). -user:metta_file_buffer(65,859002831,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2330,1),line_char(2330,3))). -user:metta_file_buffer(65,859002831,constant,'rust!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2330,4),line_char(2330,9))). -user:metta_file_buffer(65,859002831,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2330,10),line_char(2330,18))). -user:metta_file_buffer(64,859002831,metta_other,[iz,'rust!','MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2330,0),line_char(2330,19))). -user:metta_file_buffer(65,860002832,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2331,1),line_char(2331,5))). -user:metta_file_buffer(65,860002832,constant,'rust!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2331,6),line_char(2331,11))). -user:metta_file_buffer(66,860002833,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2332,3),line_char(2332,8))). -user:metta_file_buffer(66,860002833,string,"Like rust but evaluates the atom rather than entering into the space. (rust! ) and (rust !) are identical.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2332,9),line_char(2332,129))). -user:metta_file_buffer(65,860002833,metta_other,['@desc',"Like rust but evaluates the atom rather than entering into the space. (rust! ) and (rust !) are identical."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2332,2),line_char(2332,130))). -user:metta_file_buffer(66,860002834,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2333,3),line_char(2333,10))). -user:metta_file_buffer(68,860002836,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2334,5),line_char(2334,11))). -user:metta_file_buffer(68,860002836,string,"Atom to be evaluated",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2334,12),line_char(2334,34))). -user:metta_file_buffer(67,860002836,metta_other,['@param',"Atom to be evaluated"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2334,4),line_char(2334,35))). -user:metta_file_buffer(66,860002836,array,[['@param',"Atom to be evaluated"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2333,11),line_char(2334,36))). -user:metta_file_buffer(65,860002836,metta_other,['@params',[['@param',"Atom to be evaluated"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2333,2),line_char(2334,37))). -user:metta_file_buffer(66,860002837,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2335,3),line_char(2335,10))). -user:metta_file_buffer(66,860002837,string,"Result of evaluation",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2335,11),line_char(2335,33))). -user:metta_file_buffer(65,860002837,metta_other,['@return',"Result of evaluation"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2335,2),line_char(2335,34))). -user:metta_file_buffer(64,860002837,metta_other,['@doc','rust!',['@desc',"Like rust but evaluates the atom rather than entering into the space. (rust! ) and (rust !) are identical."],['@params',[['@param',"Atom to be evaluated"]]],['@return',"Result of evaluation"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2331,0),line_char(2335,35))). -user:metta_file_buffer(65,861002838,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2336,1),line_char(2336,2))). -user:metta_file_buffer(65,861002838,constant,'rust!',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2336,3),line_char(2336,8))). -user:metta_file_buffer(66,861002839,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2336,10),line_char(2336,12))). -user:metta_file_buffer(66,861002839,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2336,13),line_char(2336,17))). -user:metta_file_buffer(66,861002839,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2336,18),line_char(2336,22))). -user:metta_file_buffer(65,861002839,metta_other,[->,'Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2336,9),line_char(2336,23))). -user:metta_file_buffer(64,861002839,metta_typedecl,[:,'rust!',[->,'Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2336,0),line_char(2336,24))). -user:metta_file_buffer(65,862002840,constant,iz,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2338,1),line_char(2338,3))). -user:metta_file_buffer(65,862002840,constant,coerce,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2338,4),line_char(2338,10))). -user:metta_file_buffer(65,862002840,constant,'MeTTaLog',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2338,11),line_char(2338,19))). -user:metta_file_buffer(64,862002840,metta_other,[iz,coerce,'MeTTaLog'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2338,0),line_char(2338,20))). -user:metta_file_buffer(65,863002841,constant,'@doc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2339,1),line_char(2339,5))). -user:metta_file_buffer(65,863002841,constant,coerce,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2339,6),line_char(2339,12))). -user:metta_file_buffer(66,863002842,constant,'@desc',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2340,3),line_char(2340,8))). -user:metta_file_buffer(66,863002842,string,"Cast (coerce) Value to be of Type. Supports the basic types Atom (no-op), Number, String, and Bool.\n Number: Converts number strings and bools to numbers. True is 1, False is 0.\n String: Coerced as if Value were printed.\n Bool: False, 0, and () are False, all other values are True.",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2340,9),line_char(2343,63))). -user:metta_file_buffer(65,863002842,metta_other,['@desc',"Cast (coerce) Value to be of Type. Supports the basic types Atom (no-op), Number, String, and Bool.\n Number: Converts number strings and bools to numbers. True is 1, False is 0.\n String: Coerced as if Value were printed.\n Bool: False, 0, and () are False, all other values are True."],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2340,2),line_char(2343,64))). -user:metta_file_buffer(66,863002843,constant,'@params',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2344,3),line_char(2344,10))). -user:metta_file_buffer(68,863002845,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2345,5),line_char(2345,11))). -user:metta_file_buffer(68,863002845,string,"Type",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2345,12),line_char(2345,18))). -user:metta_file_buffer(67,863002845,metta_other,['@param',"Type"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2345,4),line_char(2345,19))). -user:metta_file_buffer(68,863002846,constant,'@param',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2346,5),line_char(2346,11))). -user:metta_file_buffer(68,863002846,string,"Value",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2346,12),line_char(2346,19))). -user:metta_file_buffer(67,863002846,metta_other,['@param',"Value"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2346,4),line_char(2346,20))). -user:metta_file_buffer(66,863002846,array,[['@param',"Type"],['@param',"Value"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2344,11),line_char(2346,21))). -user:metta_file_buffer(65,863002846,metta_other,['@params',[['@param',"Type"],['@param',"Value"]]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2344,2),line_char(2346,22))). -user:metta_file_buffer(66,863002847,constant,'@return',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2347,3),line_char(2347,10))). -user:metta_file_buffer(66,863002847,string,"Value cast to Type",[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2347,11),line_char(2347,31))). -user:metta_file_buffer(65,863002847,metta_other,['@return',"Value cast to Type"],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2347,2),line_char(2347,32))). -user:metta_file_buffer(64,863002847,metta_other,['@doc',coerce,['@desc',"Cast (coerce) Value to be of Type. Supports the basic types Atom (no-op), Number, String, and Bool.\n Number: Converts number strings and bools to numbers. True is 1, False is 0.\n String: Coerced as if Value were printed.\n Bool: False, 0, and () are False, all other values are True."],['@params',[['@param',"Type"],['@param',"Value"]]],['@return',"Value cast to Type"]],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2339,0),line_char(2347,33))). -user:metta_file_buffer(65,864002848,constant,:,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2348,1),line_char(2348,2))). -user:metta_file_buffer(65,864002848,constant,coerce,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2348,3),line_char(2348,9))). -user:metta_file_buffer(66,864002849,constant,->,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2348,11),line_char(2348,13))). -user:metta_file_buffer(66,864002849,constant,'Type',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2348,14),line_char(2348,18))). -user:metta_file_buffer(66,864002849,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2348,19),line_char(2348,23))). -user:metta_file_buffer(66,864002849,constant,'Atom',[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2348,24),line_char(2348,28))). -user:metta_file_buffer(65,864002849,metta_other,[->,'Type','Atom','Atom'],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2348,10),line_char(2348,29))). -user:metta_file_buffer(64,864002849,metta_typedecl,[:,coerce,[->,'Type','Atom','Atom']],[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2348,0),line_char(2348,30))). -user:metta_file_buffer(64,865002849,constant,end_of_file,[],'/home/deb12user/metta-wam/.Attic/metta_lang/stdlib_mettalog.metta',range(line_char(2349,0),line_char(2349,0))).