echo     coerce     let*     chain     eval-for     let     stringToChars
 
charsToString
 
repl!     rtrace!     no-rtrace!     trace!     trace     profile!     time!     print     println!     assertTrue     assertFalse     assertEqual     assertNotEqual
 
assertEqualToResult
 
new-space     case     collapse     superpose     sequential     nop     empty     do     call!     call-fn!     call-fn-nth!
 
if     If     car-atom     cdr-atom     Cons     change-state!
 
new-state     get-state     get-types     get-type     length     CountElement
 
get-metatype
 
extend-py!     register-module!
 
include!     include     load-ascii     import!     load-file!     bind!     pragma!     transfer!     save-space!     and     or     not     function     return     catch     throw     number-of     findall!     limit!     limit     offset!     offset     max-time!     max-time     call-cleanup!
 
setup-call-cleanup!
 
with-output-to!
 
maplist!     concurrent-maplist!
 
concurrent-forall!
 
hyperpose     predicate-arity
 
function-arity
 
compile-space!
 
compile!     TupleConcat     range     dedup!     intersect     make_list     call-string!
 

'intersect'( Lx1, Lx2 , Lx_intersct ):- !, eval_H( [ 'intersect', Lx1, Lx2 ], Lx_intersct ).'intersect'
 
'car-atom'(List, Head):- eval_H(['car-atom', List], Head).'car-atom'
 
'cdr-atom'(List, Tail):- eval_H(['cdr-atom', List], Tail).'cdr-atom'
 
'collapse'(List, CollapsedList):- eval_H(['collapse', List], CollapsedList).'collapse'
 
'superpose'(List, SuperposedList):- eval_H(['superpose', List], SuperposedList).'superpose'
 
'assertEqual'(Expected, Actual, Result):- ignore(Expected=Actual), eval_H(['assertEqual', Expected, Actual], Result).'assertEqual'
 
'assertEqualToResult'(Expected, Actual, Result):- eval_H(['assertEqualToResult', Expected, Actual], Result).'assertEqualToResult'
 
'assertNotEqual'(Expected, Actual, Result):- eval_H(['assertNotEqual', Expected, Actual], Result).'assertNotEqual'
 
'assertFalse'(EvalThis, Result):- eval_H(['assertFalse', EvalThis], Result).'assertFalse'
 
'assertTrue'(EvalThis, Result):- eval_H(['assertTrue', EvalThis], Result).'assertTrue'
 
'rtrace!'(Condition, EvalResult):- eval_H(['rtrace', Condition], EvalResult).'rtrace!'
 
'time!'(EvalThis, EvalResult):- eval_H(['time', EvalThis], EvalResult).'time!'
 
'repl!'(EvalResult):- eval_H(['repl!'], EvalResult).'repl!'
 
'import!'(Environment, Filename, Namespace):- eval_H(['import!', Environment, Filename], Namespace).'import!'
 
'pragma!'(Environment, Expression, EvalValue):- eval_H(['pragma!', Environment, Expression], EvalValue).'pragma!'
 
'print'(Message, EvalResult):- eval_H(['print', Message], EvalResult).'print'
 
'nop'(Expression, EvalResult):- eval_H(['nop', Expression], EvalResult).'nop'
 
'bind!'(Environment, Variable, Value):- eval_H(['bind!', Environment, Variable], Value).'bind!'
 
'let'(Variable, Expression, Body, Result):- eval_H(['let', Variable, Expression, Body], Result).'let'
 
'let*'(Bindings, Body, Result):- eval_H(['let*', Bindings, Body], Result).'let*'
 
'get-type'(Value, Type):- eval_H(['get-type', Value], Type).'get-type'
 

properties('&corelib','if', [flow_control, qhelp("Conditional execution."), conditional_execution]).'if'
 
properties('&corelib','case', [flow_control, qhelp("Case selection."), conditional_execution]).'case'
 
properties('&corelib','let', [variable_assignment, qhelp("Variable assignment.")]).'let'
 
properties('&corelib','let*', [variable_assignment, qhelp("Sequential variable assignment."), sequential]).'let*'
 
properties('&corelib','function', [function_definition, qhelp("Function block.")]).'function'
 
properties('&corelib','return', [function_definition, qhelp("Return value of a function block."), return_value]).'return'
 
properties('&corelib','catch', [error_handling, qhelp("Catches exceptions."), exception_handling]).'catch'
 
properties('&corelib','throw', [error_handling, qhelp("Throws exceptions."), exception_handling]).'throw'
 
properties('&corelib','collapse', [data_structures, qhelp("Collapses a structure."), manipulation]).'collapse'
 
properties('&corelib','sequential', [data_structures, qhelp("Sequentially applies operations."), sequential_operations]).'sequential'
 
properties('&corelib','superpose', [data_structures, qhelp("Superposes data structures."), manipulation]).'superpose'
 
properties('&corelib','dedup!', [iteration_control, qhelp("Removes duplicate elements from iteration."), manipulation]).'dedup!'
 
properties('&corelib','limit!', [iteration_control, qhelp("Limits the number of iterations.")]).'limit!'
 
properties('&corelib','offset!', [iteration_control, qhelp("Adjusts the starting point of iteration.")]).'offset!'
 
properties('&corelib','number-of', [iteration_control, qhelp("Returns iteration count.")]).'number-of'
 
properties('&corelib','nop', [iteration_control, qhelp("Suppresses iteration result."), suppression]).'nop'
 
properties('&corelib','do', [iteration_control, qhelp("Suppresses iteration result."), suppression]).'do'
 
properties('&corelib','pragma!', [compiler_directive, qhelp("Compiler directive for optimizations/settings."), optimization]).'pragma!'
 
properties('&corelib','include!', [code_inclusion, qhelp("Includes code from another file or context.")]).'include!'
 
properties('&corelib','load-ascii', [file_handling, qhelp("Loads ASCII file content.")]).'load-ascii'
 
properties('&corelib','extend-py!', [integration, qhelp("Extends integration with Python."), python]).'extend-py!'
 
properties('&corelib','import!', [module_import, qhelp("Imports an external module or file.")]).'import!'
 
properties('&corelib','eval-for', [evaluation, qhelp("Evaluates assuming a return type."), type_assumption]).'eval-for'
 
properties('&corelib','call!', [dynamic_call, qhelp("Tries to dynamically guess if predicate or function.")]).'call!'
 
properties('&corelib','predicate-arity', [function_definition, qhelp("Defines the arity of predicates/functions."), arity]).'predicate-arity'
 
properties('&corelib','call-fn!', [dynamic_call, qhelp("Calls a function dynamically."), function]).'call-fn!'
 
properties('&corelib','call-string!', [evaluation, qhelp("Evaluates a string of Prolog code."), prolog_code]).'call-string!'
 
properties('&corelib','new-space', [memory_allocation, qhelp("Allocates new space or memory region.")]).'new-space'
 
properties('&corelib','transfer!', [memory_management, qhelp("Transfers space content to another space.")]).'transfer!'
 
properties('&corelib','coerce', [type_conversion, qhelp("Forces argument types for compatibility."), compatibility]).'coerce'
 
properties('&corelib','or', [logic, qhelp("Logical OR."), logical_or]).'or'
 
properties('&corelib','and', [logic, qhelp("Logical AND."), logical_and]).'and'
 
properties('&corelib','not', [logic, qhelp("Logical NOT."), logical_not]).'not'
 
properties('&corelib','repl!', [debugging, qhelp("Interactive read-eval-print loop."), interactive]).'repl!'
 
properties('&corelib','time!', [execution_timing, qhelp("Execution timing.")]).'time!'
 
properties('&corelib','trace!', [debugging, qhelp("Prints some debug information."), information_printing]).'trace!'
 
properties('&corelib','no-rtrace!', [debugging, qhelp("Disables tracing for debugging."), trace_control]).'no-rtrace!'
 
properties('&corelib','rtrace!', [debugging, qhelp("Enables tracing for debugging."), trace_control]).'rtrace!'
 
properties('&corelib','println!', [output, qhelp("Prints text with newline to output."), text_printing]).'println!'
 
properties('&corelib','with-output-to!', [output, qhelp("Redirects output to a specified target."), redirection]).'with-output-to!'
 
properties('&corelib','print', [output, qhelp("Prints text to output."), text_printing]).'print'
 
properties('&corelib','assertEqual', [testing, qhelp("Asserts a condition is true."), assertion]).'assertEqual'
 
properties('&corelib','assertFalse', [testing, qhelp("Asserts a condition is false."), assertion]).'assertFalse'
 
properties('&corelib','assertEqual', [testing, qhelp("Asserts two values are equal."), assertion]).'assertEqual'
 
properties('&corelib','assertNotEqual', [testing, qhelp("Asserts two values are not equal."), assertion]).'assertNotEqual'
 
properties('&corelib','assertEqualToResult', [testing, qhelp("Asserts equality to a result."), assertion]).'assertEqualToResult'
 
properties('&corelib','change-state!', [state_management, qhelp("Changes the state of a system component."), system_integration]).'change-state!'
 
properties('&corelib','get-state', [state_management, qhelp("Gets the state of a component or system."), data_retrieval]).'get-state'
 
properties('&corelib','car-atom', [list_operations, qhelp("Retrieves the head of a list."), head_retrieval]).'car-atom'
 
properties('&corelib','cdr-atom', [list_operations, qhelp("Retrieves the tail of a list."), tail_retrieval]).'cdr-atom'
 
properties('&corelib','range', [list_operations, qhelp("Generates a range of numbers."), range_generation]).'range'
 
properties('&corelib','make_list', [list_operations, qhelp("Creates a list with specified elements."), creation]).'make_list'
 
properties('&corelib','Cons', [list_operations, qhelp("Constructs a list."), construction]).'Cons'
 
properties('&corelib','length', [list_operations, qhelp("Determines the length of a list."), length_determination]).'length'
 

;; probes whether functions can be executed in reverse. This involves inferring the ;; input values from given output values through inverse operations or pattern matching, !(pragma! compile full) !(pragma! table false) (= (f $x) (* 2 $x)) !(print (match &self (= (f 1) $y) $y)) !(assertEqual (match &self (= (f 1) $y) $y) (superpose (2))) ; Expected Output: [2] !(print (match &self (= (f $x) 2) $x)) !(assertEqual (match &self (= (f $x) 2) $x) (superpose (1))) ; Expected Output: [1] (print
 

Doing: timeout --foreground --kill-after=5 --signal=SIGINT 61 time metta /opt/logicmoo_workspace/packs_sys/logicmoo_opencog/MeTTa/hyperon-wam/reports/features/debugging/hyperon_experimental_issue_481.metta [False] [((Error (superpose Empty) superpose expects single expression as an argument))] [(Empty)] 0.07user 0.01system 0:00.08elapsed 100%CPU (0avgtext+0avgdata 33308maxresident)k 0inputs+0outputs (0major+3635minor)pagefaults 0swaps (superpose
 

!(bind! &ps1 (eval-for $pid (process-create! (bash) (:: -c "MeTTa server1-with-some-data.metta server2-with-some-data.metta -G \'(create-vspace-server &self 3021)\')")) (:: (process $pid)))) !(assertEqualToResult (remote-eval "localhost:3021" (match &self (, ($obj is $prop) ($prop is-a Color) ($obj is-a Planet)) (Color of Planet $obj is $prop)) ((Color of Planet Mars is Red))) !(process-kill! &ps1) (eval-for
 

[(Error (assertEqualToResult (let $_ (append (Cons 1 (Cons 2 Nil)) (Cons 3 (Cons 4 Nil)) $Out) $Out) ((Cons 1 (Cons 2 (Cons 3 (Cons 4 Nil)))))) Expected: [(Cons 1 (Cons 2 (Cons 3 (Cons 4 Nil))))] Got: [(Cons 1 (Cons 2 $R#36))] Missed result: (Cons 1 (Cons 2 (Cons 3 (Cons 4 Nil)))))] 0.06user 0.01system 0:00.08elapsed 98%CPU (0avgtext+0avgdata 34488maxresident)k 0inputs+0outputs (0major+3839minor)pagefaults 0swaps (let
 

; insert an argument into a compound term.. 0= functor, 1 = arg1 etc (= (insert-at $nth $item $list) (collapse (limit $nth (superpose $list)) $item (ofset $nth (superpose $list)))) ; call a relation making $nth the return value (= (renth $nth $list) (let $call (insert-at $nth $retval $list) (match &self (call! $call) $ret))) (let
 

; ============================================================= ; Purpose: Define predicate 'is-even' to check if a number is even. ; Operation: Uses modulo operator to determine if a number is divisible by 2 without remainder. ; Usage: General utility function for checking evenness of numbers. ; ============================================================= ; Define 'is-even' predicate (: is-even (-> Number Bool)) (= (is-even $X) (== (% $X 2) 0)) (= (: $v EvenNumber) (if (is-even $v) () (empty))) !(assertEqual (sequential ((== (get-type $even) EvenNumber) (let $even (superpose (1 2 3 4 5 6)) $even)) (superpose (2 4 6))) (let
 

(: is-even (-> Number Bool)) (= (is-even $X) (== (% $X 2) 0)) (= (fail-not-even $v) (if (is-even $v) () (empty))) !(superpose ; using nop to hide results (nop (freeze! $even fail-not-even)) ; freeze (terible name chosen by Furtwidth)) (assertEqual ; nondetermisticaly implants coide that will accept or reject bindings (let $even (superpose (1 2 3 4 5 6)) $even) (superpose (2 4 6)))) (let
 

Doing: timeout --foreground --kill-after=5 --signal=SIGINT 61 time metta /opt/logicmoo_workspace/packs_sys/logicmoo_opencog/MeTTa/hyperon-wam/reports/features/typed-variables/even-number.metta [(Error (superpose (nop (freeze! $even fail-not-even)) (assertEqual (let $even (superpose (1 2 3 4 5 6)) $even) (superpose (2 4 6)))) IncorrectNumberOfArguments)] 0.06user 0.01system 0:00.07elapsed 98%CPU (0avgtext+0avgdata 33400maxresident)k 0inputs+0outputs (0major+3654minor)pagefaults 0swaps (let