├── LICENSE
├── README.md
├── archived
    └── building_SWI-Prolog
    │   ├── README.md
    │   ├── building_swipl.graphml
    │   └── building_swipl.png
├── code
    ├── README.md
    ├── entropy
    │   └── count_identical_holes.pl
    ├── heavycarbon
    │   ├── strings
    │   │   ├── string_overwrite_performance.plt
    │   │   ├── tablify.pl
    │   │   └── tablify.plt
    │   ├── support
    │   │   ├── meta_helpers.pl
    │   │   ├── safe_format.pl
    │   │   └── throwme_nonmodular.pl
    │   ├── terms
    │   │   ├── ABSOLUTELY_EXPERIMENTAL.txt
    │   │   ├── about.txt
    │   │   ├── annotate_mirror.pl
    │   │   ├── create_random_term.pl
    │   │   ├── create_random_term_test.pl
    │   │   ├── dict_based_graph.pl
    │   │   ├── generate.pl
    │   │   ├── mirror.pl
    │   │   ├── mirror.plt
    │   │   ├── synthetisize_nodes.pl
    │   │   ├── term_printer.pl
    │   │   └── unmirror.pl
    │   └── utils
    │   │   ├── TLDR_between_with_step.txt
    │   │   ├── TLDR_between_x.txt
    │   │   ├── TLDR_lenient_length.txt
    │   │   ├── TLDR_probe_length.txt
    │   │   ├── between_with_step.pl
    │   │   ├── between_with_step.plt
    │   │   ├── between_x.pl
    │   │   ├── between_x.plt
    │   │   ├── call_graph.graphml
    │   │   ├── clashfree_id_selection.pl
    │   │   ├── clashfree_id_selection.plt
    │   │   ├── difflist_length.pl
    │   │   ├── difflist_length.plt
    │   │   ├── in_prefix.pl
    │   │   ├── in_prefix.plt
    │   │   ├── lenient_length.pl
    │   │   ├── list_of_numbered_pairs.pl
    │   │   ├── openlist_append.pl
    │   │   ├── openlist_append.plt
    │   │   ├── partition_freely.pl
    │   │   ├── partition_freely.plt
    │   │   ├── probe_length.pl
    │   │   ├── probe_length.plt
    │   │   ├── random_atom.pl
    │   │   ├── random_atom.plt
    │   │   ├── randomly_insert.pl
    │   │   ├── randomly_insert.plt
    │   │   ├── randomly_select.pl
    │   │   ├── randomly_select.plt
    │   │   ├── replace0.pl
    │   │   ├── replace0.plt
    │   │   ├── rotate_list.pl
    │   │   ├── rotate_list.plt
    │   │   ├── splinter0.pl
    │   │   ├── splinter0.plt
    │   │   ├── vector_nth0.pl
    │   │   ├── vector_nth0.plt
    │   │   ├── vector_replace0.pl
    │   │   └── vector_replace0.plt
    ├── load_and_test_script.pl
    ├── snippets
    │   ├── build_term_for_tree.pl
    │   ├── citation.pl
    │   ├── counted.pl
    │   ├── counted.plt
    │   ├── proc_self_status.pl
    │   └── snippets.pl
    ├── tree_pp
    │   ├── build_term_for_tree.pl
    │   ├── test.pl
    │   └── the goal is to prettyprint a tree.txt
    └── various
    │   ├── bitlist.pl
    │   ├── input_into_dict.pl
    │   └── is_list_2.pl
├── code_unit_tests
    ├── README.md
    ├── builtin_demo
    │   ├── test_atom_chars.pl
    │   ├── test_atom_codes.pl
    │   ├── test_atom_string.pl
    │   ├── test_compound_name_arguments.pl
    │   ├── test_compound_name_arity.pl
    │   ├── test_dicts.pl
    │   └── test_is_list.pl
    ├── run_them_all.sh
    └── simplest
    │   ├── test_fail.pl
    │   ├── test_partially_succeed.pl
    │   ├── test_succeed.pl
    │   ├── test_throw.pl
    │   └── tests_demonstrating_units_tests.pl
├── compiling
    ├── jars
    │   ├── hamcrest-2.2.jar
    │   └── junit-4.13.2.jar
    ├── logic.sh
    ├── pics
    │   ├── File Structure.graphml
    │   ├── File Structure.svg
    │   ├── File Structure_with_JPL.graphml
    │   └── File Structure_with_JPL.svg
    └── swiprologpull.sh
├── foreign_interface_trial
    └── sayhellolib
    │   ├── README.md
    │   ├── build.sh
    │   ├── mod
    │       └── sayhellolib.pl
    │   └── src
    │       └── sayhellolib.c
├── in_progress
    ├── blah
    │   ├── Prolog Terminology
    │   ├── prolog_truth_values.txt
    │   └── template programming.txt
    ├── exploring
    │   ├── exploring_chr
    │   │   └── test_chr.pl
    │   └── exploring_jpl
    │   │   ├── DCG_for_classnames_in_JPL.graphml
    │   │   ├── DCG_for_classnames_in_JPL.svg
    │   │   ├── JNI_links.md
    │   │   ├── connect_to_libreoffice
    │   │       ├── FirstUnoContact.class
    │   │       ├── FirstUnoContact.java
    │   │       ├── first_uno_contact.pl
    │   │       ├── first_uno_contact_2.pl
    │   │       ├── helpers
    │   │       │   └── write_class_inheritance.pl
    │   │       ├── setup.sh
    │   │       └── tests
    │   │       │   ├── test_gregorian_calendar.pl
    │   │       │   └── test_java_string.pl
    │   │   ├── java_classname_parsing
    │   │       ├── java_tooling
    │   │       │   └── CharRangePrinter.java
    │   │       ├── jpl.pl
    │   │       ├── jpl_exceptions.pl
    │   │       ├── jpl_java_identifier_chars.pl
    │   │       ├── jpl_java_name_parsing.pl
    │   │       └── jpl_redux.pl
    │   │   └── jplex.pl
    ├── how_does_a_predicate_execute
    │   ├── how_does_a_predicate_execute.graphml
    │   └── how_does_a_predicate_execute.svg
    ├── library_aggregate
    │   ├── README.md
    │   ├── mtcars.pl
    │   └── mtcars_help.pl
    ├── lists
    │   └── Lists.md
    ├── on_dif.md
    ├── pldoc_trick.md
    ├── prolog_clause_explainer.md
    └── weird_numbers.pl
├── jpl_java_prolog_bridge
    ├── calling_from_java
    │   ├── README.md
    │   └── callprolog
    │   │   ├── ConnectTest.java
    │   │   ├── jars
    │   │       ├── jpl.jar
    │   │       ├── junitsl.jar
    │   │       ├── logback-classic.jar
    │   │       ├── logback-core.jar
    │   │       └── slf4j-api.jar
    │   │   ├── javadoc
    │   │       ├── allclasses-index.html
    │   │       ├── allpackages-index.html
    │   │       ├── constant-values.html
    │   │       ├── deprecated-list.html
    │   │       ├── element-list
    │   │       ├── help-doc.html
    │   │       ├── index-all.html
    │   │       ├── index.html
    │   │       ├── member-search-index.js
    │   │       ├── member-search-index.zip
    │   │       ├── org
    │   │       │   └── jpl7
    │   │       │   │   ├── Atom.html
    │   │       │   │   ├── Compound.html
    │   │       │   │   ├── Dict.html
    │   │       │   │   ├── Float.html
    │   │       │   │   ├── Integer.html
    │   │       │   │   ├── JPL.html
    │   │       │   │   ├── JPLException.html
    │   │       │   │   ├── JRef.html
    │   │       │   │   ├── PrologException.html
    │   │       │   │   ├── Query.html
    │   │       │   │   ├── Rational.html
    │   │       │   │   ├── Term.html
    │   │       │   │   ├── Util.html
    │   │       │   │   ├── Variable.html
    │   │       │   │   ├── package-summary.html
    │   │       │   │   └── package-tree.html
    │   │       ├── overview-tree.html
    │   │       ├── package-search-index.js
    │   │       ├── package-search-index.zip
    │   │       ├── resources
    │   │       │   ├── glass.png
    │   │       │   └── x.png
    │   │       ├── script-dir
    │   │       │   ├── external
    │   │       │   │   └── jquery
    │   │       │   │   │   └── jquery.js
    │   │       │   ├── images
    │   │       │   │   ├── ui-bg_glass_55_fbf9ee_1x400.png
    │   │       │   │   ├── ui-bg_glass_65_dadada_1x400.png
    │   │       │   │   ├── ui-bg_glass_75_dadada_1x400.png
    │   │       │   │   ├── ui-bg_glass_75_e6e6e6_1x400.png
    │   │       │   │   ├── ui-bg_glass_95_fef1ec_1x400.png
    │   │       │   │   ├── ui-bg_highlight-soft_75_cccccc_1x100.png
    │   │       │   │   ├── ui-icons_222222_256x240.png
    │   │       │   │   ├── ui-icons_2e83ff_256x240.png
    │   │       │   │   ├── ui-icons_454545_256x240.png
    │   │       │   │   ├── ui-icons_888888_256x240.png
    │   │       │   │   └── ui-icons_cd0a0a_256x240.png
    │   │       │   ├── jquery-3.4.1.js
    │   │       │   ├── jquery-ui.css
    │   │       │   ├── jquery-ui.js
    │   │       │   ├── jquery-ui.min.css
    │   │       │   ├── jquery-ui.min.js
    │   │       │   ├── jquery-ui.structure.css
    │   │       │   ├── jquery-ui.structure.min.css
    │   │       │   ├── jszip-utils
    │   │       │   │   └── dist
    │   │       │   │   │   ├── jszip-utils-ie.js
    │   │       │   │   │   ├── jszip-utils-ie.min.js
    │   │       │   │   │   ├── jszip-utils.js
    │   │       │   │   │   └── jszip-utils.min.js
    │   │       │   └── jszip
    │   │       │   │   └── dist
    │   │       │   │       ├── jszip.js
    │   │       │   │       └── jszip.min.js
    │   │       ├── script.js
    │   │       ├── search.js
    │   │       ├── serialized-form.html
    │   │       ├── stylesheet.css
    │   │       ├── system-properties.html
    │   │       ├── type-search-index.js
    │   │       └── type-search-index.zip
    │   │   ├── javasrc
    │   │   ├── jpl7
    │   │   ├── make_javadoc.sh
    │   │   ├── original_tests
    │   │   ├── pom.xml
    │   │   ├── src
    │   │       ├── main
    │   │       │   └── java
    │   │       │   │   └── name
    │   │       │   │       └── heavycarbon
    │   │       │   │           └── jpl
    │   │       │   │               └── callprolog
    │   │       │   │                   └── Connect.java
    │   │       └── test
    │   │       │   └── java
    │   │       │       └── name
    │   │       │           └── heavycarbon
    │   │       │               └── jpl
    │   │       │                   └── callprolog
    │   │       │                       ├── ConnectTest.java
    │   │       │                       ├── JPLTest.java
    │   │       │                       └── Stuff.java
    │   │   └── target
    │   │       ├── classes
    │   │           └── name
    │   │           │   └── heavycarbon
    │   │           │       └── jpl
    │   │           │           └── callprolog
    │   │           │               └── Connect.class
    │   │       ├── maven-status
    │   │           └── maven-compiler-plugin
    │   │           │   ├── compile
    │   │           │       └── default-compile
    │   │           │       │   ├── createdFiles.lst
    │   │           │       │   └── inputFiles.lst
    │   │           │   └── testCompile
    │   │           │       └── default-testCompile
    │   │           │           ├── createdFiles.lst
    │   │           │           └── inputFiles.lst
    │   │       ├── surefire-reports
    │   │           ├── TEST-name.heavycarbon.jpl.callprolog.ConnectTest.xml
    │   │           └── name.heavycarbon.jpl.callprolog.ConnectTest.txt
    │   │       └── test-classes
    │   │           └── name
    │   │               └── heavycarbon
    │   │                   └── jpl
    │   │                       └── callprolog
    │   │                           └── ConnectTest.class
    ├── code_jpl
    │   ├── java_classname_dcg_for_jpl
    │   │   ├── final
    │   │   │   ├── jpl.pl
    │   │   │   ├── original_jpl.pl
    │   │   │   ├── original_test_jpl.pl
    │   │   │   └── test_jpl.pl
    │   │   ├── java_tooling
    │   │   │   ├── CharRangePrinter.java
    │   │   │   ├── PrintSomeEntityNames.java
    │   │   │   ├── TestPrintPrimitives.java
    │   │   │   └── result_range_check.pl
    │   │   ├── oldies
    │   │   │   └── original_dcg_of_jpl.pl
    │   │   └── pics
    │   │   │   ├── archive
    │   │   │       ├── new_dcg_calls.graphml
    │   │   │       └── new_dcg_calls.svg
    │   │   │   ├── jpl_and_java_type_descriptors.graphml
    │   │   │   ├── jpl_and_java_type_descriptors.svg
    │   │   │   ├── jpl_calling_java_and_the_converse.graphml
    │   │   │   └── jpl_calling_java_and_the_converse.svg
    │   └── new_exceptions_for_jpl
    │   │   ├── unfinished_attempt_to_parse_prolog_source
    │   │       ├── extract_throwmes.pl
    │   │       └── extract_throws_from_original.pl
    │   │   └── verifying_throwme_calls_in_jpl
    │   │       ├── exception_descriptors.pl
    │   │       ├── exception_testcode.pl
    │   │       ├── exception_thrower.pl
    │   │       └── perl
    │   │           └── perl_throwme_extractor.pl
    ├── modding_jpl
    │   └── README.md
    └── structure_of_jpl_src
    │   ├── organization_in_distro.graphml
    │   ├── organization_in_distro.png
    │   └── organization_in_distro.svg
├── other_notes
    ├── about_byrd_box_model
    │   ├── README.md
    │   └── pics
    │   │   ├── byrd_box_examples.graphml
    │   │   ├── byrd_box_examples.svg
    │   │   ├── byrd_box_model.graphml
    │   │   ├── byrd_box_model.png
    │   │   ├── byrd_box_model.svg
    │   │   ├── byrd_box_model_port_names.graphml
    │   │   ├── byrd_box_model_port_names.svg
    │   │   ├── byrd_box_model_with_term_store.graphml
    │   │   ├── byrd_box_model_with_term_store.svg
    │   │   ├── commit_rollback.graphml
    │   │   ├── commit_rollback.png
    │   │   ├── original_byrd_box.png
    │   │   ├── term_store_versioning.graphml
    │   │   ├── term_store_versioning.png
    │   │   └── term_store_versioning.svg
    ├── about_depicting_terms
    │   ├── README.md
    │   ├── pics
    │   │   ├── Example_1.graphml
    │   │   ├── Example_1.png
    │   │   ├── Example_2.graphml
    │   │   ├── Example_2.png
    │   │   ├── Example_3.graphml
    │   │   ├── Example_3.png
    │   │   ├── Example_Compound_Term_List.graphml
    │   │   ├── Example_Compound_Term_List.png
    │   │   ├── Example_Compound_Term_Open_List.graphml
    │   │   ├── Example_Compound_Term_Open_List.png
    │   │   ├── Symbols.graphml
    │   │   ├── Symbols.png
    │   │   ├── Vocabulary.graphml
    │   │   └── Vocabulary.png
    │   ├── pics2
    │   │   ├── prolog_term_notation.graphml
    │   │   ├── prolog_term_notation.png
    │   │   └── prolog_term_notation.svg
    │   └── roles_of_terms.md
    ├── about_f_logic
    │   ├── README.md
    │   └── pics
    │   │   └── parts_of_the_isa_hierarchy.png
    ├── about_fibonacci_numbers
    │   ├── Fibonacci.graphml
    │   ├── Fibonacci.png
    │   ├── Fibonacci.svg
    │   ├── README.md
    │   ├── Two entries discovered on Rosettacode which I dont get.txt
    │   ├── fibonacci_algorithms.pl
    │   └── fibonacci_algorithms.plt
    ├── about_foldl_and_foldr
    │   ├── README.md
    │   ├── dcg_foldl.pl
    │   ├── foldl_and_foldr.md
    │   ├── foldr_for_library_apply
    │   │   ├── README.md
    │   │   ├── foldr_recursive.pl
    │   │   ├── foldr_using_reverse.pl
    │   │   └── tests
    │   │   │   ├── test_apply.pl
    │   │   │   ├── test_foldl.pl
    │   │   │   └── test_foldr.pl
    │   ├── foldy.pl
    │   ├── foo_foldl.pl
    │   ├── foo_foldr.pl
    │   ├── foo_foldx.graphml
    │   ├── foo_foldx.pl
    │   ├── foo_foldx.png
    │   ├── linear_foldl_with_maplist4.md
    │   └── maplist_foldl.pl
    ├── about_list_processing
    │   ├── README.md
    │   └── pics
    │   │   ├── difference_list_explainer.graphml
    │   │   ├── difference_list_explainer.png
    │   │   ├── difference_list_explainer.svg
    │   │   ├── idioms.png
    │   │   ├── list_processing_idioms.graphml
    │   │   ├── list_processing_idioms.png
    │   │   └── list_processing_idioms.svg
    ├── about_monads
    │   ├── Java Optional.graphml
    │   └── Java Optional.png
    ├── about_negation
    │   ├── README.md
    │   ├── double_negation.md
    │   ├── floundering.md
    │   └── pics
    │   │   ├── another_graph_for_naf.graphml
    │   │   ├── another_graph_for_naf.png
    │   │   ├── another_graph_for_naf.svg
    │   │   ├── byrd_box_view_of_negation.graphml
    │   │   ├── byrd_box_view_of_negation.png
    │   │   ├── cover_LNCS238.jpg
    │   │   ├── cover_LNCS764.png
    │   │   ├── domains_of_negation.graphml
    │   │   ├── domains_of_negation.png
    │   │   ├── predicate_graph.graphml
    │   │   ├── predicate_graph.png
    │   │   ├── some_extended_logical_values.graphml
    │   │   ├── some_extended_logical_values.png
    │   │   ├── some_extended_logical_values.svg
    │   │   ├── where_is_the_set_naf.graphml
    │   │   ├── where_is_the_set_naf.png
    │   │   └── where_is_the_set_naf.svg
    ├── about_papers_of_interest
    │   └── README.md
    ├── about_power_of_prolog_on_youtube
    │   └── README.md
    ├── about_prolog_extensions
    │   └── README.md
    ├── about_rule_based_systems
    │   ├── README.md
    │   ├── pics
    │   │   ├── RuleML family (from RuleML Perspective on Reaction Rule Standards by Adrian Paschke).png
    │   │   ├── fwd_and_bwd_chaining.graphml
    │   │   ├── fwd_and_bwd_chaining.png
    │   │   ├── fwd_and_bwd_chaining.svg
    │   │   ├── one_LPS_cycle.graphml
    │   │   ├── one_LPS_cycle.png
    │   │   ├── reactive_rule_fire.graphml
    │   │   └── reactive_rule_fire.png
    │   └── so_text
    │   │   └── fwd_and_bwd_chaining.txt
    ├── about_the_logic
    │   └── README.md
    ├── about_truth_values
    │   ├── README.md
    │   └── pics
    │   │   ├── extended_truth_values.graphml
    │   │   ├── extended_truth_values.png
    │   │   └── extended_truth_values.svg
    ├── about_vocabulary
    │   └── README.md
    ├── about_well_founded_semantics
    │   └── README.md
    └── quick_map_of_lp_landscape
    │   ├── README.md
    │   ├── quick_map_of_lp_landscape.graphml
    │   ├── quick_map_of_lp_landscape.png
    │   └── quick_map_of_lp_landscape.svg
├── pics
    ├── cosine_taylor_series
    │   ├── taylor_series.graphml
    │   └── taylor_series.png
    ├── program trees
    │   ├── clauses.graphml
    │   └── clauses.png
    ├── prolog_clause_explainer
    │   ├── Prolog Calling AND Tree.graphml
    │   ├── Prolog Calling AND Tree.png
    │   ├── Prolog Calling.graphml
    │   ├── Prolog Calling.png
    │   ├── Prolog Clause Logical Reading.graphml
    │   ├── Prolog Clause Logical Reading.png
    │   ├── Prolog Clause Network.graphml
    │   ├── Prolog Clause Network.png
    │   ├── Prolog Clause.graphml
    │   ├── Prolog Clause.png
    │   ├── Prolog Infoflow.graphml
    │   ├── Prolog Infoflow.png
    │   ├── Prolog Tree of Stuff.graphml
    │   └── Prolog Tree of Stuff.png
    ├── variables_and_their_bindings
    │   ├── Variables and their bindings.graphml
    │   └── Variables and their bindings.png
    └── various
    │   ├── Hiroshige_Shinagawa_Station.jpg
    │   ├── Powerful_Prolog_and_AI_Bookshelf.jpg
    │   └── Taxonomy of programming Paradigms (by Peter van Roy).png
├── prolog_comparison_predicates
    ├── prolog_comparison_predicates.md
    ├── prolog_comparison_predicates.ods
    ├── prolog_comparison_predicates.pdf
    └── prolog_comparison_predicates.png
├── prolog_exercises
    ├── TODO_insert_element_into_sorted_list_using_difflist.txt
    ├── ab_dcg
    │   ├── ab_dcg.pl
    │   └── test_ab_dcg.pl
    ├── asymetry.pl
    ├── between_sym.pl
    ├── bitstring dcg.pl
    ├── digits_dcg
    │   ├── digits_dcg.pl
    │   └── test_digits_dcg.pl
    ├── experimenting_with_number_generation
    │   ├── tuple_via_coroutines.pl
    │   ├── tuple_via_generation.pl
    │   ├── tuple_via_induction.pl
    │   └── tuple_via_member_escalator.pl
    ├── extremal.pl
    ├── forward_chainer.pl
    ├── freeze_example.pl
    ├── grailsearch
    │   └── grailsearch.pl
    ├── graphs
    │   └── probabilistic_pather.pl
    ├── hierarchical_sorting
    │   ├── hierarchical_sorting_example.pl
    │   ├── hierarchical_sorting_with_commalists.pl
    │   └── hierarchical_sorting_with_pairs.pl
    ├── minlist_maxlist.pl
    ├── peano_numbers
    │   ├── README.md
    │   ├── peano.pl
    │   ├── peano.plt
    │   ├── peano_add_1.pl
    │   └── peano_numbers_as_lists.pl
    ├── puzzles
    │   ├── three-digit_master_mind.pl
    │   ├── u2_crosses_the_bridge.pl
    │   └── who_is_the_hacker.pl
    ├── remember_digits_sequences
    │   └── digits_tree.pl
    ├── rosettacode
    │   └── sort_disjoint_sublist
    │   │   ├── README.txt
    │   │   ├── sds_sol_1.pl
    │   │   ├── sds_sol_2.pl
    │   │   └── sds_unittests.pl
    ├── sat.pl
    ├── schuberts_steamroller.pl
    ├── simple_prolog_db_operation.pl
    ├── stackoverflow
    │   ├── Breadth-First Traversal of a List of Lists.txt
    │   ├── Threading State.txt
    │   ├── compare dcg to other approaches.pl
    │   ├── constraints_over_matrix.pl
    │   ├── corona_symptoms.pl
    │   ├── cosine_taylor_series.md
    │   ├── flatten_and_heighten.pl
    │   ├── flatwalker.pl
    │   ├── insert_element_into_sorted_list_with_append.pl
    │   ├── parse_time.pl
    │   ├── powersum.pl
    │   ├── powersum
    │   │   ├── constraints.graphml
    │   │   └── constraints.svg
    │   ├── rgbnext.pl
    │   ├── simple graph walker (finite automaton).pl
    │   └── sliding.pl
    └── test_plunit.pl
├── swipl_notes
    ├── README.md
    ├── about_attributed_variables
    │   ├── README.md
    │   ├── enforced_integer_list.pl
    │   ├── enum_domain.pl
    │   ├── enum_domain.plt
    │   ├── list_test.pl
    │   ├── merging_attributed_variables
    │   │   ├── merging_attributed_variables.graphml
    │   │   ├── merging_attributed_variables.png
    │   │   └── merging_attributed_variables.svg
    │   └── when_is_the_hook_triggered
    │   │   ├── when_is_the_hook_triggered.ods
    │   │   ├── when_is_the_hook_triggered.pdf
    │   │   └── when_is_the_hook_triggered.png
    ├── about_between
    │   ├── README.md
    │   ├── code
    │   │   └── test_between.pl
    │   └── webmanualtxt
    │   │   └── between.txt
    ├── about_call_with_depth_limit
    │   └── code
    │   │   └── deeper.pl
    ├── about_chr
    │   └── Logical Interpretation of CHR.png
    ├── about_concept_of_variable
    │   ├── README.md
    │   ├── concept_of_variable.graphml
    │   ├── concept_of_variable.png
    │   ├── concept_of_variable.svg
    │   ├── unification_example.graphml
    │   ├── unification_example.png
    │   └── unification_example.svg
    ├── about_conditions
    │   ├── README.md
    │   └── code
    │   │   ├── condition_examples.pl
    │   │   ├── continuation_based_condition.pl
    │   │   ├── modified_condition.pl
    │   │   └── original_condition.pl
    ├── about_continuations
    │   ├── README.md
    │   ├── adaptations
    │   │   └── loop.md
    │   ├── archive
    │   │   └── faulty_code
    │   │   │   ├── Faulty prolog program structure.graphml
    │   │   │   ├── Faulty prolog program structure.png
    │   │   │   ├── Faulty prolog program structure.svg
    │   │   │   └── explodes3.pl
    │   ├── code
    │   │   ├── effect_handler
    │   │   │   ├── effect_handler.pl
    │   │   │   ├── run_counter.pl
    │   │   │   └── run_markov.pl
    │   │   ├── exercise
    │   │   │   ├── appender_observer.pl
    │   │   │   ├── jumping_around.pl
    │   │   │   ├── looping.pl
    │   │   │   └── trial.pl
    │   │   ├── iterator
    │   │   │   ├── iterator.pl
    │   │   │   └── pics
    │   │   │   │   ├── iterator_and_master_coroutine.graphml
    │   │   │   │   ├── iterator_and_master_coroutine.png
    │   │   │   │   └── iterator_and_master_coroutine.svg
    │   │   ├── producer_consumer
    │   │   │   ├── producer_consumer_master.pl
    │   │   │   └── producer_consumer_master_multi.pl
    │   │   └── trial
    │   │   │   └── reset_and_reset.pl
    │   └── pics
    │   │   ├── back_and_forth.graphml
    │   │   ├── back_and_forth.png
    │   │   ├── limited_application.graphml
    │   │   ├── limited_application.png
    │   │   ├── limited_application.svg
    │   │   ├── reset_points_as_resources.graphml
    │   │   ├── reset_points_as_resources.png
    │   │   ├── reset_points_as_resources.svg
    │   │   ├── reset_points_as_resources_call_stack.graphml
    │   │   ├── reset_points_as_resources_call_stack.png
    │   │   ├── reset_points_as_resources_call_stack.svg
    │   │   ├── state_handler.graphml
    │   │   ├── state_handler.svg
    │   │   ├── successfully_switching_between_2_branches_on_the_stack.graphml
    │   │   ├── successfully_switching_between_2_branches_on_the_stack.png
    │   │   └── successfully_switching_between_2_branches_on_the_stack.svg
    ├── about_dcgs
    │   ├── README.md
    │   ├── example_abba
    │   │   ├── README.md
    │   │   ├── abba2.pl
    │   │   ├── fsm_2.graphml
    │   │   ├── fsm_diagram.graphml
    │   │   ├── fsm_perl.pl
    │   │   ├── fsm_prolog.pl
    │   │   ├── fsm_prolog_debug.pl
    │   │   ├── pics
    │   │   │   ├── fsm_1.graphml
    │   │   │   ├── fsm_1.svg
    │   │   │   ├── fsm_2.graphml
    │   │   │   └── fsm_2.svg
    │   │   ├── regex_fsm_1.graphml
    │   │   ├── regex_fsm_1.svg
    │   │   ├── regex_fsm_2.graphml
    │   │   ├── regex_fsm_2.png
    │   │   └── regex_fsm_2.svg
    │   ├── example_dcg_for_abstar.pl
    │   ├── read_file.pl
    │   └── text_for_DCG_page.pl
    ├── about_dicts
    │   ├── README.md
    │   ├── code
    │   │   ├── applications
    │   │   │   ├── count_values_encountered.pl
    │   │   │   ├── selection_for_default_parameters.pl
    │   │   │   └── sum_over_numeric_values.pl
    │   │   ├── dict_assembly_disassembly_testing.pl
    │   │   ├── dict_equality_testing.pl
    │   │   ├── dict_getting_testing.pl
    │   │   ├── dict_put_dotcall_testing.pl
    │   │   ├── dict_selection_testing.pl
    │   │   ├── dict_unification_testing.pl
    │   │   ├── load_all_run_tests.pl
    │   │   └── perf
    │   │   │   └── dict_perf_test.pl
    │   └── manual_review
    │   │   ├── dict_manual_review.pdf
    │   │   ├── extensions.doc
    │   │   └── extensions.html
    ├── about_dif
    │   ├── README.md
    │   ├── old
    │   │   ├── about_dif_states.graphml
    │   │   └── about_dif_states.svg
    │   └── pics
    │   │   ├── dif_call.graphml
    │   │   ├── dif_call.svg
    │   │   ├── unifications_after_dif_call.graphml
    │   │   └── unifications_after_dif_call.svg
    ├── about_difference_lists
    │   ├── README.md
    │   ├── code
    │   │   ├── README.md
    │   │   ├── difflist_examples.pl
    │   │   └── length_dl_sly.pl
    │   └── pics
    │   │   ├── 01A.graphml
    │   │   ├── 01A.png
    │   │   ├── 01B.graphml
    │   │   ├── 01B.png
    │   │   ├── 02A.graphml
    │   │   ├── 02A.png
    │   │   ├── 02B.graphml
    │   │   ├── 02B.png
    │   │   ├── 02C.graphml
    │   │   ├── 02C.png
    │   │   ├── 02D.graphml
    │   │   ├── 02D.png
    │   │   ├── 02E.graphml
    │   │   ├── 02E.png
    │   │   ├── 02F.graphml
    │   │   ├── 02F.png
    │   │   ├── 03A.graphml
    │   │   ├── 03A.png
    │   │   ├── 03B.graphml
    │   │   ├── 03B.png
    │   │   ├── 03C.graphml
    │   │   ├── 03C.png
    │   │   ├── 03D.graphml
    │   │   ├── 03D.png
    │   │   ├── 03E.graphml
    │   │   ├── 03E.png
    │   │   ├── 03F.graphml
    │   │   ├── 03F.png
    │   │   ├── 04A.graphml
    │   │   ├── 04A.png
    │   │   ├── 04B.graphml
    │   │   ├── 04B.png
    │   │   ├── 04C.graphml
    │   │   ├── 04C.png
    │   │   ├── 04D.graphml
    │   │   ├── 04D.png
    │   │   ├── 04E.graphml
    │   │   ├── 04E.png
    │   │   ├── 04F.graphml
    │   │   ├── 04F.png
    │   │   ├── 05A.graphml
    │   │   ├── 05A.png
    │   │   ├── 05B.graphml
    │   │   ├── 05B.png
    │   │   ├── 05C.graphml
    │   │   ├── 05C.png
    │   │   ├── 05D.graphml
    │   │   ├── 05D.png
    │   │   ├── 05E.graphml
    │   │   └── 05E.png
    ├── about_documentation
    │   ├── README.md
    │   ├── bibliography
    │   │   ├── README.md
    │   │   └── pics
    │   │   │   ├── pdflatex-bibtex_pipeline.graphml
    │   │   │   └── pdflatex-bibtex_pipeline.png
    │   └── pics
    │   │   ├── editing_process.graphml
    │   │   ├── editing_process.png
    │   │   ├── findall_predicate_banner.png
    │   │   ├── guillements_example.png
    │   │   ├── quotation_marks.png
    │   │   ├── result_of_term_dotlists_true.png
    │   │   ├── result_of_testing_typesetting_empty_list.png
    │   │   └── result_of_typesetting_term.png
    ├── about_exceptions
    │   ├── README.md
    │   ├── catch_with_backtrace.md
    │   ├── code
    │   │   ├── case_study.pl
    │   │   ├── catchy.pl
    │   │   ├── exception_testcode.pl
    │   │   └── perl_throwme_extractor.pl
    │   ├── example_code_to_verify_predicate_args.md
    │   ├── pics
    │   │   ├── Java_Exception_Hierarchy.graphml
    │   │   ├── Java_Exception_Hierarchy.png
    │   │   ├── Java_Exception_Hierarchy.svg
    │   │   └── prolog_coding_guidelines_exceptions.png
    │   ├── problems_with_the_iso_standard_exception_terms.md
    │   ├── throwing_in_style.md
    │   └── throwing_iso_standard_exceptions.md
    ├── about_findall
    │   ├── README.md
    │   └── pics
    │   │   ├── cover_LNCS238.jpg
    │   │   ├── cover_art_of_prolog_1st_edition.jpg
    │   │   ├── cover_craft_of_prolog.jpg
    │   │   ├── cover_programming_in_prolog.jpg
    │   │   └── findall_is_pretty_acme.jpg
    ├── about_foldl
    │   └── README.md
    ├── about_freeze
    │   └── README.md
    ├── about_glossary
    │   └── README.md
    ├── about_if_then_else
    │   ├── README.md
    │   └── pics
    │   │   ├── cut_as_wired_up_in_the_byrd_box_model.graphml
    │   │   ├── cut_as_wired_up_in_the_byrd_box_model.png
    │   │   ├── if_then_as_wired_up_in_the_byrd_box_model.graphml
    │   │   ├── if_then_as_wired_up_in_the_byrd_box_model.png
    │   │   ├── if_then_else_as_parsed.graphml
    │   │   ├── if_then_else_as_parsed.png
    │   │   ├── if_then_else_as_wired_up_in_the_byrd_box_model.graphml
    │   │   ├── if_then_else_as_wired_up_in_the_byrd_box_model.png
    │   │   ├── if_then_else_as_wired_up_in_the_byrd_box_model_p_fails.graphml
    │   │   ├── if_then_else_as_wired_up_in_the_byrd_box_model_p_fails.png
    │   │   ├── if_then_else_as_wired_up_in_the_byrd_box_model_p_succeeds.graphml
    │   │   ├── if_then_else_as_wired_up_in_the_byrd_box_model_p_succeeds.png
    │   │   ├── if_then_else_as_written.graphml
    │   │   ├── if_then_else_as_written.png
    │   │   ├── or_as_wired_up_in_the_byrd_box_model.graphml
    │   │   ├── or_as_wired_up_in_the_byrd_box_model.png
    │   │   ├── soft_cut_as_wired_up_in_the_byrd_box_model.graphml
    │   │   ├── soft_cut_as_wired_up_in_the_byrd_box_model.png
    │   │   ├── soft_cut_as_wired_up_in_the_byrd_box_model_p_fails.graphml
    │   │   ├── soft_cut_as_wired_up_in_the_byrd_box_model_p_fails.png
    │   │   ├── soft_cut_as_wired_up_in_the_byrd_box_model_p_succeeds.graphml
    │   │   └── soft_cut_as_wired_up_in_the_byrd_box_model_p_succeeds.png
    ├── about_jpl
    │   └── test_jpl.pl
    ├── about_length
    │   ├── README.md
    │   ├── code
    │   │   ├── test_length.pl
    │   │   └── test_length_against_iso_prolog_wg17.pl
    │   └── webmanualtxt
    │   │   └── length.txt
    ├── about_maplist
    │   ├── README.md
    │   ├── maplist_2_examples.md
    │   ├── maplist_3_examples.md
    │   ├── maplist_4_examples.md
    │   ├── pics
    │   │   ├── mutually_cyclic_lists.graphml
    │   │   └── mutually_cyclic_lists.svg
    │   └── webmanualtxt
    │   │   └── maplist_2.txt
    ├── about_mode_indicators
    │   ├── README.md
    │   ├── mode_indicators.ods
    │   ├── mode_indicators.pdf
    │   └── mode_indicators.png
    ├── about_operators
    │   ├── README.md
    │   ├── code
    │   │   ├── list_ops.pl
    │   │   └── list_ops_with_urls.pl
    │   └── pics
    │   │   ├── parse_tree.graphml
    │   │   ├── parse_tree.png
    │   │   ├── parse_tree_with_precedence_values.graphml
    │   │   └── parse_tree_with_precedence_values.png
    ├── about_output_formatting
    │   ├── README.md
    │   ├── format_2_cheatsheet
    │   │   ├── format_2_cheatsheet.ods
    │   │   ├── format_2_cheatsheet.pdf
    │   │   └── format_2_cheatsheet.png
    │   └── output_formatting_pics
    │   │   ├── tldr.graphml
    │   │   └── tldr.svg
    ├── about_packs
    │   └── README.md
    ├── about_pengines
    │   ├── Pengine PLTP diagram.graphml
    │   └── Pengine PLTP diagram.svg
    ├── about_predicate_structure
    │   ├── README.md
    │   ├── falsing_and_error_throwing.graphml
    │   ├── falsing_and_error_throwing.png
    │   └── falsing_and_error_throwing.svg
    ├── about_prolog_db_operations
    │   └── simple_db_op.md
    ├── about_salvaging_a_term_out_of_a_dropped_search_branch
    │   ├── README.md
    │   └── pics
    │   │   ├── simple_straightforward_call_illustration.graphml
    │   │   ├── simple_straightforward_call_illustration.png
    │   │   └── simple_straightforward_call_illustration.svg
    ├── about_swipl_data_types
    │   ├── README.md
    │   ├── archive
    │   │   ├── old
    │   │   │   ├── pseudotypes.graphml
    │   │   │   └── pseudotypes.png
    │   │   └── older
    │   │   │   ├── prolog_syntax.graphml
    │   │   │   └── prolog_syntax.png
    │   ├── code
    │   │   └── tagging.pl
    │   ├── swipl_data_type_tree
    │   │   ├── swipl_data_type_tree.graphml
    │   │   ├── swipl_data_type_tree.odt
    │   │   ├── swipl_data_type_tree.pdf
    │   │   ├── swipl_data_type_tree.png
    │   │   ├── swipl_data_type_tree.svg
    │   │   └── swipl_data_type_tree.txt
    │   └── webmanualtxt
    │   │   └── type_tree_in_ascii.txt
    ├── about_tabling
    │   └── README.md
    ├── about_term_analysis_and_construction
    │   ├── README.md
    │   ├── term_analysis_construction.ods
    │   ├── term_analysis_construction.pdf
    │   ├── term_analysis_construction.png
    │   └── test_compound_name_arguments.pl
    ├── about_type_tests
    │   ├── README.md
    │   └── unit_tests_for_must_be.pl
    ├── various
    │   ├── loading_lynx_library.md
    │   ├── notes_on_the_caret_used_in_bagof_goals.md
    │   └── swipl_string_modes.md
    └── various_code
    │   ├── division_and_remainder.pl
    │   └── test_sort_predicates.pl
├── terms_variables_jargon
    ├── README.md
    └── prolog_lingo
    │   ├── prolog_lingo.ods
    │   ├── prolog_lingo.pdf
    │   └── prolog_lingo.png
├── third_party_code
    ├── plspec-master
    │   ├── .gitignore
    │   ├── .travis.yml
    │   ├── LICENSE.md
    │   ├── README.md
    │   └── plspec
    │   │   ├── Makefile
    │   │   ├── builtins.plspec
    │   │   ├── domain.pl
    │   │   ├── domain_test.pl
    │   │   ├── plspec.pl
    │   │   ├── plspec_core.pl
    │   │   ├── plspec_logger.pl
    │   │   ├── plspec_test.pl
    │   │   ├── plspec_test.plspec
    │   │   ├── preserve_behaviour_test.pl
    │   │   ├── prettyprinter.pl
    │   │   ├── tests.pl
    │   │   ├── unbound_spec_test.pl
    │   │   ├── validator.pl
    │   │   └── validator_test.pl
    └── snippets
    │   └── O Keefe's flatten.txt
├── vivid_logic
    ├── README.md
    ├── code
    │   └── vl.pl
    └── pics
    │   └── lnai764cover.png
└── website_comment_texts
    ├── BLOBs.txt
    ├── DCG.txt
    ├── Foreign Function Interface.txt
    ├── JPL.txt
    ├── Manual_Contents.txt
    ├── Manual_Intro.txt
    ├── PCRE.txt
    ├── SWI-Prolog_Manual_Intro.txt
    ├── Syntax_Changes.txt
    ├── aggregate.txt
    ├── append.txt
    ├── assertion.txt
    ├── atom_concat_3.txt
    ├── atom_length.txt
    ├── atom_string.txt
    ├── atomic_concat_3.txt
    ├── atomic_list_concat_2.txt
    ├── atomic_list_concat_3.txt
    ├── atomics_to_string_2.txt
    ├── atomics_to_string_3.txt
    ├── attributed_variables.txt
    ├── bagof.txt
    ├── between.txt
    ├── bidicts.txt
    ├── bitshift.txt
    ├── call_dcg.txt
    ├── call_with_depth_limit.txt
    ├── catch.txt
    ├── char_type.txt
    ├── clumped.txt
    ├── cmdline.txt
    ├── consult.txt
    ├── current_module.txt
    ├── current_prolog_flag.txt
    ├── cut.txt
    ├── cyclic_term.txt
    ├── db.txt
    ├── defining_a_module.txt
    ├── delimited_continuations.txt
    ├── dict_get.pl
    ├── dict_pairs.txt
    ├── dict_projection.pl
    ├── dif.txt
    ├── digit.txt
    ├── doc_needs_help.md
    ├── download.txt
    ├── engines.txt
    ├── exception_term.txt
    ├── exists_file.txt
    ├── file_base_name.txt
    ├── file_name_extension.txt
    ├── findall_3.txt
    ├── findall_4.txt
    ├── float.txt
    ├── foldl.txt
    ├── forall.txt
    ├── foreign_language_interface.txt
    ├── format.txt
    ├── get_dict.txt
    ├── get_single_char.txt
    ├── get_time.txt
    ├── glossary.txt
    ├── howto_pack.txt
    ├── include.txt
    ├── is_list.txt
    ├── last.txt
    ├── library_strings.txt
    ├── library_yall.txt
    ├── load_test_files.txt
    ├── maplist.txt
    ├── max_list.txt
    ├── max_member.txt
    ├── member.txt
    ├── memberchk.txt
    ├── metacall.txt
    ├── min.txt
    ├── mode_indicators.txt
    ├── multifile.txt
    ├── must_be.txt
    ├── nb_setarg.txt
    ├── nb_setval.txt
    ├── nonground.txt
    ├── not.txt
    ├── not_unifies.txt
    ├── notation_of_predicate_descriptions.txt
    ├── nth0.txt
    ├── obtaining_runtime_statistics.txt
    ├── once.txt
    ├── op.txt
    ├── option.txt
    ├── option_3.txt
    ├── partition.txt
    ├── pengines.txt
    ├── pldoc.txt
    ├── plunit.txt
    ├── predicate_property.txt
    ├── predicate_semicolon.txt
    ├── process_create.txt
    ├── put_dict.pl
    ├── put_dict.txt
    ├── put_docall.pl
    ├── put_dotcall.pl
    ├── random_1_the_function.txt
    ├── random_between.txt
    ├── random_member.txt
    ├── read.txt
    ├── read_line_to_string.txt
    ├── read_stream_to_codes.txt
    ├── reset.txt
    ├── reverse.txt
    ├── run_tests.txt
    ├── same_length.txt
    ├── setup_call_cleanup.txt
    ├── setup_call_cleanup_3.txt
    ├── shell.txt
    ├── sleep.txt
    ├── sort_2.txt
    ├── split_string.txt
    ├── string_length.txt
    ├── string_predicates.txt
    ├── sub_string.pl
    ├── sum.pl
    ├── sum_list.txt
    ├── time.txt
    ├── transparent predicates.txt
    ├── unification.txt
    ├── univ.txt
    ├── uuid.txt
    ├── var.txt
    ├── whymodules.pl
    └── write_length.txt


/LICENSE:
--------------------------------------------------------------------------------
 1 | Some stuff is marked as licensed with: 
 2 | 
 3 | https://opensource.org/licenses/0BSD
 4 | 
 5 | but unless noted otherwise, the UNLICENSE applies:
 6 | 
 7 | ---
 8 | This is free and unencumbered software released into the public domain.
 9 | 
10 | Anyone is free to copy, modify, publish, use, compile, sell, or
11 | distribute this software, either in source code form or as a compiled
12 | binary, for any purpose, commercial or non-commercial, and by any
13 | means.
14 | 
15 | In jurisdictions that recognize copyright laws, the author or authors
16 | of this software dedicate any and all copyright interest in the
17 | software to the public domain. We make this dedication for the benefit
18 | of the public at large and to the detriment of our heirs and
19 | successors. We intend this dedication to be an overt act of
20 | relinquishment in perpetuity of all present and future rights to this
21 | software under copyright law.
22 | 
23 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
26 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
27 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
28 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
29 | OTHER DEALINGS IN THE SOFTWARE.
30 | 
31 | For more information, please refer to <http://unlicense.org>
32 | ---
33 | 


--------------------------------------------------------------------------------
/archived/building_SWI-Prolog/README.md:
--------------------------------------------------------------------------------
1 | # How to build SWI Prolog
2 | 
3 | These diagrams are now obsolete since SWI Prolog
4 | has dropped the complex bash script scheme and
5 | is now using CMAKE (this happened somewhen in 2018)
6 | 
7 | 


--------------------------------------------------------------------------------
/archived/building_SWI-Prolog/building_swipl.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/archived/building_SWI-Prolog/building_swipl.png


--------------------------------------------------------------------------------
/code/README.md:
--------------------------------------------------------------------------------
 1 | # Code grabbag
 2 | 
 3 | ## Explainer
 4 | 
 5 | The following file that is basically an explainer of how I organize & load modules and unit tests.
 6 | 
 7 | It is also a Prolog program, that when executed, does exactly that (for my setup).
 8 | 
 9 | [`load_and_test_script.pl`](load_and_test_script.pl)
10 | 
11 | ## Code is in the process of being moved
12 | 
13 | The code is being moved to the github repository [prolog_code](https://github.com/dtonhofer/prolog_code)
14 | 
15 | That repository features a [separate directory](https://github.com/dtonhofer/prolog_code/tree/main/packed) with SWI-Prolog "pack" files.
16 | 
17 | The README at the top of the moved code tree is [here](https://github.com/dtonhofer/prolog_code/blob/main/unpacked/onepointfour_basics/README.md)
18 | 


--------------------------------------------------------------------------------
/code/heavycarbon/strings/tablify.plt:
--------------------------------------------------------------------------------
 1 | :- use_module(library('heavycarbon/strings/tablify.pl')).
 2 | 
 3 | test_tablify(Lines) :-
 4 |    NEX=visit_next,
 5 |    PRO=probed,
 6 |    VID=visited,
 7 |    dict_create(DataSet,dataset,[
 8 |       a:vertex{name:a, prior:'', local_cost:100, overall_cost:1000000, state:NEX, hops:100},
 9 |       b:vertex{name:b, prior:calpha,  local_cost:10 , overall_cost:100, state:PRO, hops:100}
10 |    ]),
11 |    dict_create(TableDesc,tabledesc,[
12 |       1:col{key:name,         header:"Name",         justify:center},
13 |       2:col{key:prior,        header:"Prior",        justify:center},
14 |       3:col{key:local_cost,   header:"Local cost",   justify:right},
15 |       4:col{key:overall_cost, header:"Overall cost", justify:right},
16 |       5:col{key:state,        header:"State",        justify:center, enum:[NEX,PRO,VID]},
17 |       6:col{key:hops,         header:"Hops",         justify:right}
18 |    ]),
19 |    tablify(TableDesc,DataSet,Lines,_MaxWidthsDict).
20 | 
21 | :- begin_tests(tablify).
22 | 
23 | test(1) :- 
24 |    test_tablify(Lines),
25 |    assertion(nth0(0,Lines,"+------+--------+------------+--------------+------------+------+")),
26 |    assertion(nth0(1,Lines,"| Name | Prior  | Local cost | Overall cost |   State    | Hops |")),
27 |    assertion(nth0(2,Lines,"+------+--------+------------+--------------+------------+------+")),
28 |    assertion(nth0(3,Lines,"|  a   |        |        100 |      1000000 | visit_next |  100 |")),
29 |    assertion(nth0(4,Lines,"|  b   | calpha |         10 |          100 |   probed   |  100 |")),
30 |    assertion(nth0(5,Lines,"+------+--------+------------+--------------+------------+------+")).
31 | 
32 | :- end_tests(tablify).
33 | 


--------------------------------------------------------------------------------
/code/heavycarbon/terms/ABSOLUTELY_EXPERIMENTAL.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/code/heavycarbon/terms/ABSOLUTELY_EXPERIMENTAL.txt


--------------------------------------------------------------------------------
/code/heavycarbon/terms/create_random_term_test.pl:
--------------------------------------------------------------------------------
 1 | :- include(library('heavycarbon/terms/create_random_term.pl')).
 2 | 
 3 | :- debug(random_term).
 4 | 
 5 | :- begin_tests(create_random_term).
 6 | 
 7 | /*
 8 | test("list") :- 
 9 |    node_at_random(list,N,Length),
10 |    debug(random_term,"list: obtained ~q",[N]).
11 | 
12 | test("open_list") :- 
13 |    node_at_random(open_list,N,Length).
14 |    debug(random_term,"open_list: obtained ~q",[N]).
15 | 
16 | test("hole") :- 
17 |    node_at_random(hole,N,Length).
18 |    debug(random_term,"hole: obtained ~q",[N]).
19 | 
20 | test("atom") :- 
21 |    node_at_random(atom,N,Length).
22 |    debug(random_term,"atom: obtained ~q",[N]).
23 | 
24 | test("compound") :- 
25 |    node_at_random(compound,N,Length).
26 |    debug(random_term,"compound: obtained ~q",[N]).
27 | */
28 | 
29 | test("dict of various lengths") :- 
30 |    maplist([Length]>>
31 |       (node_at_random(dict,N,Length),
32 |        debug(random_term,"dict: obtained ~q",[N]))
33 |       [0,1,2]).
34 | 
35 | 
36 | 
37 |    
38 | 
39 | 
40 | :- end_tests(create_random_term).
41 | 


--------------------------------------------------------------------------------
/code/heavycarbon/terms/dict_based_graph.pl:
--------------------------------------------------------------------------------
 1 | Let's build a dict-based graph to represent terms.
 2 | 
 3 | Features for terms:
 4 | 
 5 | - One source node. If the graph is a tree, this is the root.
 6 | - Directed graph.
 7 | - Cycle detection.
 8 | - Possibility to detect & compress shread subgraphs.
 9 | - Inner Nodes & Leaf Nodes
10 | - Leaf Nodes are "Atomic" or "Holes"
11 | - Inner Nodes are "Compound" of arity 0...N
12 | 
13 | - Holes can be referenced from multiple places: The Hole is "shared"
14 | - Subgraphs can be referenced from multiple places: Structure sharing (The size of the tree in which structure sharing is invisble increases quickly)
15 | - 
16 | 
17 | 
18 | - Needs reference counting
19 | - Needs depth numbers
20 | - Needs path numbering
21 | 
22 | - How to represent this:
23 | 
24 | - A dictionary with nodes - The keys are UUIDs, the values are compound terms
25 |   Try to keep it ground (?)
26 |   structure:  
27 |      type of node: 
28 |         inner, 
29 |         leaf/atomic leaf/hole/UUID of hole possibly reference to actual datum (not that it works like UUID as you can compare)
30 |      name of node: 
31 |         name
32 |      
33 | - A dictionary with edges - The keys are UUIDs, the values are compound terms
34 | 
35 | 
36 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/TLDR_between_with_step.txt:
--------------------------------------------------------------------------------
 1 | To use between_with_step.pl:
 2 | 
 3 | 1)
 4 | 
 5 | Set up a directory hierarchy with the Prolog module and the Prolog plunit code in your directory $FOO like this, wherever $FOO is:
 6 | 
 7 | $FOO
 8 | └── modules/
 9 |     └── heavycarbon/
10 |         └── utils/
11 |             ├── between_with_step.pl    <-- the source for between/4 and between/5 in module "between_with_step"
12 |             └── between_with_step.plt   <-- the source for the plunit test "between_with_step" (which will be put into module "plunit_between_with_step")
13 | 
14 | 2)
15 | 
16 | Start SWI Prolog
17 | 
18 | Add the topmost directory to the library search path (replace $FOO as usual with an actual path):
19 | 
20 | ?- assertz(file_search_path(library,'$FOO/heavycarbon')).
21 | 
22 | 3)
23 | 
24 | Load the module, which (confusingly) is given by file name, not module name:
25 | 
26 | ?- use_module(library('heavycarbon/utils/between_with_step.pl')).
27 | 
28 | 4)
29 | 
30 | Load the associated .plt files automagically:
31 | 
32 | ?- load_test_files([]).
33 | true.
34 | 
35 | 5)
36 | 
37 | Run tests
38 | 
39 | ?- run_tests.
40 | % PL-Unit: between_with_step ................................................................................ done
41 | % All 80 tests passed
42 | true.
43 | 
44 | 6)
45 | 
46 | Use between/4 and between/5 as usual.
47 | 
48 | (Sadly, help(between/4). and help(between/5). do not work yet).
49 | 
50 | X)
51 | 
52 | For totally more on this: https://github.com/dtonhofer/prolog_notes/blob/master/code/load_and_test_script.pl
53 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/TLDR_between_x.txt:
--------------------------------------------------------------------------------
 1 | To use between_x.pl:
 2 | 
 3 | 1)
 4 | 
 5 | Set up a directory hierarchy with the Prolog module and the Prolog plunit code in your directory $FOO like this, wherever $FOO is:
 6 | 
 7 | $FOO
 8 | └── modules/
 9 |     └── heavycarbon/
10 |         └── utils/
11 |             ├── between_x.pl    <-- the source for betweenx/3 in module "between_x"
12 |             └── between_x.plt   <-- the source for the plunit test "between_x" (which will be put into module "plunit_between_x")
13 | 
14 | 2)
15 | 
16 | Start SWI Prolog
17 | 
18 | Add the topmost directory to the library search path (replace $FOO as usual with an actual path):
19 | 
20 | ?- assertz(file_search_path(library,'$FOO/heavycarbon')).
21 | 
22 | 3)
23 | 
24 | Load the module, which (confusingly) is given by file name, not module name:
25 | 
26 | ?- use_module(library('heavycarbon/utils/between_x.pl')).
27 | 
28 | 4)
29 | 
30 | Load the associated .plt files automagically:
31 | 
32 | ?- load_test_files([]).
33 | true.
34 | 
35 | 5)
36 | 
37 | Run tests
38 | 
39 | ?- run_tests.
40 | % PL-Unit: between_x ............ done
41 | % All 12 tests passed
42 | true.
43 | 
44 | 6)
45 | 
46 | Use between/4 and between/5 as usual.
47 | 
48 | (Sadly, help(between/4). and help(between/5). do not work yet).
49 | 
50 | X)
51 | 
52 | For totally more on this: https://github.com/dtonhofer/prolog_notes/blob/master/code/load_and_test_script.pl
53 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/TLDR_lenient_length.txt:
--------------------------------------------------------------------------------
 1 | To use lenient_length.pl:
 2 | 
 3 | 1)
 4 | 
 5 | Set up a directory hierarchy with the Prolog module in your directory $FOO like this, wherever $FOO is:
 6 | 
 7 | $FOO
 8 | └── modules/
 9 |     └── heavycarbon/
10 |         └── utils/
11 |             └── lenient_length.pl    <-- the source for length/3 in module "lenient_length"
12 | 
13 | 2)
14 | 
15 | Start SWI Prolog
16 | 
17 | Add the topmost directory to the library search path (replace $FOO as usual with an actual path):
18 | 
19 | ?- assertz(file_search_path(library,'$FOO/heavycarbon')).
20 | 
21 | 3)
22 | 
23 | Load the module, which (confusingly) is given by file name, not module name:
24 | 
25 | ?- use_module(library('heavycarbon/utils/lenient_length.pl')).
26 | 
27 | 4)
28 | 
29 | Use length/3
30 | 
31 | X)
32 | 
33 | For totally more on this: https://github.com/dtonhofer/prolog_notes/blob/master/code/load_and_test_script.pl
34 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/TLDR_probe_length.txt:
--------------------------------------------------------------------------------
 1 | To use probe_length.pl:
 2 | 
 3 | 1)
 4 | 
 5 | Set up a directory hierarchy with the Prolog module and the Prolog plunit code in your directory $FOO like this, wherever $FOO is:
 6 | 
 7 | $FOO
 8 | └── modules/
 9 |     └── heavycarbon/
10 |         └── utils/
11 |             ├── probe_length.pl    <-- the source for probe_length/2 and probe_length/3 in module "probe_length"
12 |             └── probe_length.plt   <-- the source for the plunit test "probe_length" (which will be put into module "plunit_probe_length")
13 | 
14 | 2)
15 | 
16 | Start SWI Prolog
17 | 
18 | Add the topmost directory to the library search path (replace $FOO as usual with an actual path):
19 | 
20 | ?- assertz(file_search_path(library,'$FOO/heavycarbon')).
21 | 
22 | 3)
23 | 
24 | Load the module, which (confusingly) is given by file name, not module name:
25 | 
26 | ?- use_module(library('heavycarbon/utils/probe_length.pl')).
27 | 
28 | 4)
29 | 
30 | Load the associated .plt files automagically:
31 | 
32 | ?- load_test_files([]).
33 | true.
34 | 
35 | 5)
36 | 
37 | Run tests
38 | 
39 | ?- run_tests.
40 | % PL-Unit: probe_length ............. done
41 | % All 13 tests passed
42 | true.
43 | 
44 | 6)
45 | 
46 | Use probe_length/3 and probe_length/4 as usual.
47 | 
48 | (Sadly, help(probe_length/3). and help(probe_length/4). do not work yet).
49 | 
50 | X)
51 | 
52 | For totally more on this: https://github.com/dtonhofer/prolog_notes/blob/master/code/load_and_test_script.pl
53 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/in_prefix.plt:
--------------------------------------------------------------------------------
 1 | :- use_module(library('heavycarbon/utils/in_prefix.pl')).
 2 | 
 3 | :- begin_tests(in_prefix).
 4 | 
 5 | test(one) :-
 6 |    in_prefix(X,[X,1,2]).
 7 | 
 8 | test(two,[fail]) :-
 9 |    in_prefix(_X,[1,2|_U]).
10 | 
11 | test(three,[fail]) :-
12 |    in_prefix(_X,[1,2,_U]).
13 | 
14 | test(four) :-
15 |    in_prefix(1,[1,_X,_U]).
16 | 
17 | test(five,[fail]) :-
18 |    in_prefix(3,[1,2,_U]).
19 | 
20 | test(six,[fail]) :-
21 |    in_prefix(3,[]).
22 | 
23 | test(seven,[fail]) :-
24 |    in_prefix(3,foo).
25 | 
26 | test(eight,[fail]) :-
27 |    in_prefix(3,_).
28 | 
29 | test(nine,[fail]) :-
30 |    in_prefix_with_stoplist(x,[x,y],[y,x]).
31 | 
32 | test(ten) :-
33 |    in_prefix_with_stoplist(x,[x,y],[x,y]).
34 | 
35 | test(eleven,[fail]) :-
36 |    in_prefix_with_stoplist(X,[X,Y],[a,b,c,Y,X]).
37 | 
38 | test(twelve) :-
39 |    in_prefix_with_stoplist(X,[X,Y],[a,b,c,X,Y]).
40 | 
41 | test(thirteen) :-
42 |    in_prefix_with_stoplist(X,[Y],[a,b,c,X,Y]).
43 | 
44 | test(fourteen,[fail]) :-
45 |    in_prefix_with_stoplist(X,[Y],[a,b,c,Y,X]).
46 | 
47 | :- end_tests(in_prefix).
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/list_of_numbered_pairs.pl:
--------------------------------------------------------------------------------
 1 | :- module(heavycarbon_list_of_numbered_pairs,
 2 |    [
 3 |    list_of_numbered_pairs/2  % -Pairs,+Length
 4 |    ]).
 5 | 
 6 | % A quick hack working in one direction for now.
 7 | %
 8 | % ?- list_of_numbered_pairs(3,N).
 9 | % N = [0-_11910, 1-_11898, 2-_11886].
10 | 
11 | list_of_numbered_pairs(Pairs,Length) :-
12 |    var(Pairs),
13 |    !,
14 |    must_be(nonneg,Length), % also checked in length/2
15 |    length(Pairs,Length),   % create list Pairs of length "Length", possibly the empty list
16 |    ((Length>0)             % fill with pairs, numbered with 0..Length-1 on the pairs' first argument
17 |     -> (succ(Max,Length),
18 |         findall(N-_,between(0,Max,N),Pairs))
19 |     ;  Pairs=[]).
20 | 
21 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/random_atom.plt:
--------------------------------------------------------------------------------
 1 | :- use_module(library('heavycarbon/utils/random_atom.pl')).
 2 | 
 3 | % This is not really a test, just code to exercise the random_atom
 4 | % module. There is no failure criterium.
 5 | 
 6 | :- debug(random_atom). % print
 7 | 
 8 | :- begin_tests(random_atom).
 9 | 
10 | test("exercising random_char/1") :-
11 |    length(R,100),
12 |    maplist(random_char,R),
13 |    debug(random_atom,"random_char delivers: ~q",[R]).
14 | 
15 | test("random_text/2, produce atom of length 0",fail) :-
16 |    random_text(_Text,0).
17 | 
18 | test("random_text/2, produce atom of length 0: if have to set option") :-
19 |    random_text(_Text,0,[empty(yes)]).
20 | 
21 | test("random_text/2, produce atom of length 0: can be explicitly disallowed",fail) :-
22 |    random_text(_Text,0,[empty(no)]).
23 | 
24 | test("random_text/3, demand length 10, run 100x") :-
25 |    length(R,100),
26 |    maplist([Text]>>random_text(Text,10),R),
27 |    maplist([Text]>>(assertion((atom(Text),atom_length(Text,10)))),R),
28 |    debug(random_atom,"random atoms of length 10: ~q",[R]).
29 | 
30 | test("random_text/3, random length, including length 0, run 100x") :-
31 |    length(R,100),
32 |    maplist([Text-Len]>>random_text(Text,Len,[empty(yes)]),R),
33 |    maplist([Text-Len]>>(assertion((atom(Text),atom_length(Text,Len),Len>=0))),R),
34 |    debug(random_atom,"random atoms of random length: ~q",[R]).
35 | 
36 | test("random_atom/3, random length but not length 0, run 100x") :-
37 |    length(R,100),
38 |    maplist([Text-Len]>>random_text(Text,Len,[empty(no)]),R),
39 |    maplist([Text-Len]>>(assertion((atom(Text),atom_length(Text,Len),Len>0))),R),
40 |    debug(random_atom,"random atoms of random length, but not empty: ~q",[R]).
41 | 
42 | :- end_tests(random_atom).
43 | 
44 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/randomly_insert.pl:
--------------------------------------------------------------------------------
 1 | :- module(heavycarbon_randomly_insert,
 2 |           [
 3 |              randomly_insert/3   % randomly_insert(@Element,+List,-ListNew)
 4 |           ]).
 5 | 
 6 | % ===
 7 | % Insert "Element" at a random position in "List", yielding "ListNew".
 8 | % ===
 9 | 
10 | randomly_insert(Element,List,ListNew) :-
11 |    must_be(list,List),
12 |    length(List,L),
13 |    random_between(0,L,Pos),                     % If L is 0, Pos will be necessarily 0
14 |    length(Prefix,Pos),                          % *Creates* a list of "Pos" fresh variables
15 |    append(Prefix,Suffix,List),                  % Run append/3 in reverse, splitting List (one solution only)
16 |    append([Prefix,[Element],Suffix],ListNew).   % Run append/2 forward, unify with ListNew
17 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/randomly_insert.plt:
--------------------------------------------------------------------------------
 1 | :- use_module(library('heavycarbon/utils/randomly_insert.pl')).
 2 | 
 3 | % :- debug(randomly_insert).
 4 | 
 5 | :- begin_tests(randomly_insert).
 6 | 
 7 | the_test(L) :-
 8 |    length(L,5),
 9 |    bagof(true,member("XXXXXXX",L),Bag),
10 |    length(Bag,1).
11 | 
12 | test("randomly inserting into nonempty list, multiple times") :-
13 |    L=[one,two,three,four],
14 |    length(R,20),
15 |    % Fill list R with examples of having randomly inserted "XXXXXXX" into L
16 |    maplist(([LN]>>randomly_insert("XXXXXXX",L,LN)),R),
17 |    % Perform some slight verification
18 |    debug(randomly_insert,"We obtained ~q",[R]),
19 |    maplist(the_test,R).
20 | 
21 | test("randomly inserting into empty list", true(R == ["XXXXXXX"])) :-
22 |    randomly_insert("XXXXXXX",[],R).
23 | 
24 | :- end_tests(randomly_insert).
25 | 
26 | 
27 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/replace0.pl:
--------------------------------------------------------------------------------
 1 | :- module(replace0,
 2 |           [
 3 |              replace0/5    % replace0(List, N, NewItem, OldItem, NewList)
 4 |           ]).
 5 | 
 6 | % ===
 7 | % replace0/5 is simply based on splinter0/5
 8 | %
 9 | % "Replace operation at 0-based position "N" in "List" with "NewItem",
10 | %  gives "NewList", with the old item in "OldItem"
11 | % ===
12 | 
13 | replace0(List, N, NewItem, OldItem, NewList) :-
14 |    splinter0(List, N, Prefix, OldItem, Suffix),
15 |    append([Prefix, [NewItem], Suffix], NewList).
16 | 
17 | 
18 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/replace0.plt:
--------------------------------------------------------------------------------
 1 | :- use_module(library('heavycarbon/utils/replace0.pl')).
 2 | 
 3 | :- begin_tests(replace0).
 4 | 
 5 | % ---
 6 | % normal replace
 7 | % ---
 8 | 
 9 | test(replace0_0) :- replace0([a,b,c],0,rep(A),A,NewList), A=a, NewList = [rep(a), b, c].
10 | test(replace0_1) :- replace0([a,b,c],1,rep(B),B,NewList), B=b, NewList = [a, rep(b), c].
11 | test(replace0_2) :- replace0([a,b,c],2,rep(C),C,NewList), C=c, NewList = [a, b, rep(c)].
12 | 
13 | % ---
14 | % testing error conditions
15 | % ---
16 | 
17 | % Negative index throws.
18 | % Positive but out of bounds index causes failure.
19 | 
20 | test(replace0_fail_0,[fail])               :- replace0([a,b,c],3,_,_,_).
21 | test(replace0_fail_1,[fail])               :- replace0([],0,_,_,_).
22 | test(replace0_fail_2,[throws(error(_,_))]) :- replace0([a,b,c],-1,_,_,_).
23 | 
24 | :- end_tests(replace0).
25 | 
26 | 
27 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/rotate_list.plt:
--------------------------------------------------------------------------------
 1 | :- use_module(library('heavycarbon/utils/rotate_list.pl')).
 2 | 
 3 | :- begin_tests(rotate_list).
 4 | 
 5 | test(empty1) :- rotate_list([], 0,R), R=[].
 6 | test(empty2) :- rotate_list([], 1,R), R=[].
 7 | test(empty3) :- rotate_list([],-1,R), R=[].
 8 | 
 9 | test(three3m6) :- rotate_list([1,2,3],-6,R), R=[1,2,3].
10 | test(three3m5) :- rotate_list([1,2,3],-5,R), R=[2,3,1].
11 | test(three3m4) :- rotate_list([1,2,3],-4,R), R=[3,1,2].
12 | test(three3m3) :- rotate_list([1,2,3],-3,R), R=[1,2,3].
13 | test(three3m2) :- rotate_list([1,2,3],-2,R), R=[2,3,1].
14 | test(three3m1) :- rotate_list([1,2,3],-1,R), R=[3,1,2].
15 | test(three3z)  :- rotate_list([1,2,3],+0,R), R=[1,2,3].
16 | test(three3p1) :- rotate_list([1,2,3],+1,R), R=[2,3,1].
17 | test(three3p2) :- rotate_list([1,2,3],+2,R), R=[3,1,2].
18 | test(three3p3) :- rotate_list([1,2,3],+3,R), R=[1,2,3].
19 | test(three3p4) :- rotate_list([1,2,3],+4,R), R=[2,3,1].
20 | test(three3p5) :- rotate_list([1,2,3],+5,R), R=[3,1,2].
21 | test(three3p6) :- rotate_list([1,2,3],+6,R), R=[1,2,3].
22 | test(three3p7) :- rotate_list([1,2,3],+7,R), R=[2,3,1].
23 | test(three3p8) :- rotate_list([1,2,3],+8,R), R=[3,1,2].
24 | 
25 | test(three3zvar)  :- rotate_list([S0,S1,S2],+0,R), R=[S0,S1,S2].
26 | test(three3p1var) :- rotate_list([S0,S1,S2],+1,R), R=[S1,S2,S0].
27 | test(three3p2var) :- rotate_list([S0,S1,S2],+2,R), R=[S2,S0,S1].
28 | test(three3p3var) :- rotate_list([S0,S1,S2],+3,R), rotate_list([S0,S1,S2],0,R).
29 | test(three3p4var) :- rotate_list([S0,S1,S2],+4,R), rotate_list([S0,S1,S2],1,R).
30 | test(three3p5var) :- rotate_list([S0,S1,S2],+5,R), rotate_list([S0,S1,S2],2,R).
31 | 
32 | :- end_tests(rotate_list).
33 | 
34 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/vector_nth0.plt:
--------------------------------------------------------------------------------
 1 | :- use_module(library('heavycarbon/utils/vector_nth0.pl')).
 2 | 
 3 | :- begin_tests(vector_nth0).
 4 | 
 5 | % Extracting elements using known "Indexes"
 6 | 
 7 | test(extract_1)    :- vector_nth0([]     ,[a,b,c,d,e,f],R), R=[].
 8 | test(extract_2)    :- vector_nth0([0,1,2],[a,b,c,d,e,f],R), R=[a,b,c].
 9 | test(extract_3)    :- vector_nth0([2,0,1],[a,b,c,d,e,f],R), R=[c,a,b].
10 | test(extract_3)    :- vector_nth0([3,3,3],[a,b,c,d,e,f],R), R=[d,d,d].
11 | 
12 | % Pulling values into "List" with fresh variables
13 | 
14 | test(pull)         :- vector_nth0([0,1,2],[A,B,C,_,_,_],[a,b,c]), A=a,B=b,C=c.
15 | 
16 | % Searching for matching element if "Indexes" contains fresh variables
17 | 
18 | test(search_1)     :- findall(Ixs,vector_nth0(Ixs,[a,b,c,d,e,f,g],[d,c,b]),SetIxs), SetIxs=[[3,2,1]].
19 | test(search_2)     :- findall(Ixs,vector_nth0(Ixs,[a,b,c,b,e,c,g],[d,c,b]),SetIxs), SetIxs=[].
20 | test(search_3)     :- findall(Ixs,vector_nth0(Ixs,[a,b,c,b,e,c,g],[b,c,a]),SetIxs), SetIxs=[[1,2,0], [1,5,0], [3,2,0], [3,5,0]].
21 | 
22 | % Edge case
23 | 
24 | test(edge_1)       :- vector_nth0([],[],R), R=[].
25 | 
26 | % At least one of Indexes and Elements must be nonvar(_).
27 | 
28 | test(free,[fail])  :- vector_nth0(_I,[a,b,c],_E).
29 | 
30 | % Out-of-bound tests
31 | 
32 | test(oob_1,[fail]) :- vector_nth0([1],[],_).
33 | test(oob_2,[fail]) :- vector_nth0([-1],[a,b,c],_).
34 | test(oob_3,[fail]) :- vector_nth0([3],[a,b,c],_).
35 | 
36 | :- end_tests(vector_nth0).
37 | 
38 | 
39 | 


--------------------------------------------------------------------------------
/code/heavycarbon/utils/vector_replace0.plt:
--------------------------------------------------------------------------------
 1 | :- use_module(library('heavycarbon/utils/vector_replace0.pl')).
 2 | 
 3 | :- begin_tests(vector_replace0).
 4 | 
 5 | test(empty)  :- vector_replace0([],[],LO,RPs),
 6 |                 LO=[],RPs=[].
 7 | 
 8 | test(nop_op) :- vector_replace0([a,b,c,d],[],LO,RPs),
 9 |                 LO=[a,b,c,d],RPs=[].
10 | 
11 | test(one)    :- vector_replace0([a],[0-xxx],LO,RPs),
12 |                 LO=[xxx],RPs=[0-a].
13 | 
14 | test(two)    :- vector_replace0([a,b,c,d],[3-y,1-x],LO,RPs),
15 |                 LO=[a,x,c,y],RPs=[1-b,3-d].
16 | 
17 | test(full)   :- vector_replace0([a,b,c,d],[0-e,1-f,2-g,3-h],LO,RPs),
18 |                 LO=[e,f,g,h],RPs=[0-a,1-b,2-c,3-d].
19 | 
20 | test(bad,[throws(_)]) :- vector_replace0([a],[0-x,0-y],_,_).
21 | test(bad,[throws(_)]) :- vector_replace0([a],[1-y],_,_).
22 | 
23 | test(no_infoloss) :- IN=[a,b,c,d],
24 |                      INREP=[0-e,1-f,2-g,3-h],
25 |                      vector_replace0(IN,INREP,OUT,OUTREP),
26 |                      vector_replace0(OUT,OUTREP,IN,INREP).
27 | 
28 | :- end_tests(vector_replace0).
29 | 
30 | 


--------------------------------------------------------------------------------
/code/snippets/citation.pl:
--------------------------------------------------------------------------------
 1 | citation :-
 2 |    писатель(1,Author),
 3 |    цитирование(1,Citation),
 4 |    format("Author: ~s~nCitation: ~s~n",[Author,Citation]).
 5 | 
 6 | % Facts!
 7 | 
 8 | писатель(1,"Р.П.Уоррен").
 9 | цитирование(1,"Ты должна сделать добро из зла, потому что его больше не из чего сделать.").
10 | 


--------------------------------------------------------------------------------
/code/snippets/counted.pl:
--------------------------------------------------------------------------------
 1 | % ============================================================================
 2 | % Counting the occurence of atomic terms in a list.
 3 | % ============================================================================
 4 | % Load module and run tests with:
 5 | % 
 6 | % ?- use_module(library('snippets/counted.pl')).
 7 | % true.
 8 | % 
 9 | % ?- load_test_files([]).
10 | % true.
11 | % 
12 | % ?- run_tests.
13 | % ============================================================================
14 | 
15 | :- module(snippets_counted,
16 |           [
17 |           counted/3
18 |           ]).
19 | 
20 | % ===         
21 | % "Items" is a list of atomic (and thus ground) terms
22 | % that will appear as keys in an SWI-Prolog dict.
23 | %
24 | % "CountsDict" is an SWI-Prolog dict mapping every
25 | % "Item" encountered in "Items" to its occurrence count.
26 | % The tag of "CountsDict" is (unified with) "Tag".
27 | %
28 | % counted(+Items,-CountsDict,+Tag)
29 | % ===
30 | 
31 | counted(Items,CountsDict,Tag) :-
32 |    dict_create(EmptyDict,Tag,[]),
33 |    foldl(inc_for_key,Items,EmptyDict,CountsDict).
34 | 
35 | % ---
36 | % Private helper
37 | % ---
38 | 
39 | inc_for_key(Item,DictIn,DictOut) :-
40 |    assertion(atomic(Item)),     % lookup in a dict works via unification of atomic terms; make sure it's atomic
41 |    (get_dict(Item,DictIn,Count) % how efficient is lookup in a dict (is it a linear scan for an unifiying element?)
42 |     ->
43 |     succ(Count,CountNext)
44 |     ;
45 |     CountNext=1),
46 |    put_dict(Item,DictIn,CountNext,DictOut).
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/code/snippets/counted.plt:
--------------------------------------------------------------------------------
 1 | :- use_module(library('snippets/counted.pl')).
 2 | 
 3 | :- begin_tests(counted).
 4 | 
 5 | test("count empty list",true(Result == counts{})) :-
 6 |    counted([],Result,counts).
 7 | 
 8 | test("#1",true(Result == foo{a:4,b:2,c:3,d:1,e:1,f:1})) :-
 9 |    counted([a,b,c,d,c,e,b,a,a,f,a,c],Result,foo).
10 | 
11 | test("#2",true(Result == foo{' ':1,!:1,',':1,'H':1,'W':1,d:1,e:1,l:3,o:2,r:1})) :-
12 |    atom_chars("Hello, World!",Chars),
13 |    counted(Chars,Result,foo).
14 | 
15 | :- end_tests(counted).
16 |  
17 | 


--------------------------------------------------------------------------------
/code/tree_pp/test.pl:
--------------------------------------------------------------------------------
 1 | 
 2 | :- use_module(library('tree_pp/build_term_for_tree.pl')).
 3 | 
 4 | edge(a,[]).
 5 | edge(b,a).
 6 | edge(c,a).
 7 | edge(d,b).
 8 | edge(e,b).
 9 | edge(f,c).
10 | edge(g,c).
11 | edge(h,d).
12 | edge(i,d).
13 | edge(j,e).
14 | edge(k,e).
15 | edge(l,f).
16 | edge(m,f).
17 | edge(n,g).
18 | edge(o,g).
19 | 
20 | testit(X) :-
21 |    build_term(X).
22 | 
23 | 


--------------------------------------------------------------------------------
/code_unit_tests/README.md:
--------------------------------------------------------------------------------
 1 | # Unit tests
 2 | 
 3 | This directory contains unit tests for some SWI Prolog predicates written with [`plunit`](https://eu.swi-prolog.org/pldoc/doc_for?object=section(%27packages/plunit.html%27)), the unit testing framework.
 4 | 
 5 | `run_them_all.sh` is a bash script which, for each file listed (for now, the files have to be listed explicitly in `run_them_all.sh`,
 6 | there is no automatic collection) starts a SWI-Prolog process which loads the file (which is supposed to contain one or more _plunit_ test blocks)
 7 | and the calls [`run_tests/0`](https://eu.swi-prolog.org/pldoc/doc_for?object=run_tests/0), executing all the _plunit_ blocks. Ouput to STDERR or STDOUT
 8 | is captured in a newly created file, one for every listed file (this is a bit impractical and will have to be changed)
 9 | 
10 | The command run the _plunit_ looks more or less like this:
11 | 
12 | ```text
13 | swipl -g ""set_test_options([silent(true)]) , (run_tests -> halt(0) ; halt(1))" $test_file 1>$tmp_file 2>&1
14 | ```
15 | 
16 | ## Directories
17 | 
18 | - [`simplest`](simplest/) - Simplest possible unit tests to demonstrate unit testing itself. Take a look once as introduction.
19 | - [`builtin_demo`](builtin_demo/) - Unit test for some SWI-Prolog built-in predicates. These are useful for documentation as they say a
20 |   lot more than a long description in prose and they have a formalized, clear format. Plus, they are executable. 
21 |   **Use unit tests for documentation!**
22 | 
23 | 
24 | 
25 | 


--------------------------------------------------------------------------------
/code_unit_tests/builtin_demo/test_dicts.pl:
--------------------------------------------------------------------------------
 1 | % Simple testing of SWI-Prolog dicts
 2 | 
 3 | :- begin_tests(dicts).
 4 | 
 5 |    % obtaining dicts
 6 | 
 7 |    const_dict(xyz, _{x:alpha, y:beta, z:gamma}).
 8 |    const_dict(idx, _{id1:v(11), id2:w(22), id3:w(33), id4:v(44), id5:w(55), id6:w(66)}).
 9 | 
10 |    test("get value using valid key",true(Val == alpha)) :-
11 |        const_dict(xyz,Dc),
12 |        get_dict(x,Dc,Val).
13 | 
14 |    test("get value using nonexistent key",fail)  :- 
15 |       const_dict(xyz,Dc), 
16 |       get_dict(bar,Dc,_).
17 | 
18 |    test("check value using valid key, against the correct value") :-
19 |       const_dict(xyz,Dc), 
20 |       get_dict(x,Dc,alpha).
21 | 
22 |    test("check value using valid key, against a bad value", fail) :-
23 |       const_dict(xyz,Dc),
24 |       get_dict(x,Dc,xxxxx).
25 | 
26 |    test("get all keys",true(SortedBag == [x-alpha,y-beta,z-gamma])) :- 
27 |       const_dict(xyz,Dc), 
28 |       bagof((Key-Val),get_dict(Key,Dc,Val),Bag),
29 |       keysort(Bag,SortedBag).
30 | 
31 |    test("get selected keys by unifiying with a value",true(SortedBag == [id2-22,id3-33,id5-55,id6-66])) :-
32 |       const_dict(idx,Dc), 
33 |       bagof((Key-Val),get_dict(Key,Dc,w(Val)),Bag), % select ALSO on the form of the value
34 |       keysort(Bag,SortedBag).
35 | 
36 | :- end_tests(dict).
37 | 
38 | 
39 | 


--------------------------------------------------------------------------------
/code_unit_tests/builtin_demo/test_is_list.pl:
--------------------------------------------------------------------------------
 1 | % A bunch of unit tests which explains the behaviour of is_list/1
 2 | % https://eu.swi-prolog.org/pldoc/doc_for?object=is_list/1
 3 | 
 4 | :- begin_tests(is_list).
 5 | 
 6 | give_me_cyclic(L) :- L = [1,2,3|L].
 7 | 
 8 | test("An open list is not a list",fail) :-
 9 |    is_list([a,b,c|_]).
10 | 
11 | test("An atom is not a list",fail) :-
12 |    is_list(x).
13 | 
14 | test("A dict is not a list (actually it's a compound term)",fail) :-
15 |    is_list(_{}).
16 | 
17 | test("An unbound variable is not a list", fail) :-
18 |    is_list(_List).
19 | 
20 | test("A cyclic term is cyclic") :- 
21 |    give_me_cyclic(L),
22 |    cyclic_term(L).
23 | 
24 | test("A cyclic term is not a list") :-
25 |    give_me_cyclic(L),
26 |    \+ is_list(L).
27 | 
28 | :- end_tests(is_list).
29 |  
30 | 


--------------------------------------------------------------------------------
/code_unit_tests/simplest/test_fail.pl:
--------------------------------------------------------------------------------
1 | :- begin_tests(fail).
2 | 
3 |    test("just fail") :- fail.
4 | 
5 | :- end_tests(fail).
6 | 
7 | 


--------------------------------------------------------------------------------
/code_unit_tests/simplest/test_partially_succeed.pl:
--------------------------------------------------------------------------------
1 | :- begin_tests(partially_succeed).
2 | 
3 |    test("just succeed") :- true.
4 |    test("just fail")    :- fail.
5 | 
6 | :- end_tests(partially_succeed).
7 | 
8 | 


--------------------------------------------------------------------------------
/code_unit_tests/simplest/test_succeed.pl:
--------------------------------------------------------------------------------
1 | :- begin_tests(succeed).
2 | 
3 |    test("just succeed") :- true.
4 | 
5 | :- end_tests(succeed).
6 | 
7 | 


--------------------------------------------------------------------------------
/code_unit_tests/simplest/test_throw.pl:
--------------------------------------------------------------------------------
1 | :- begin_tests(throw).
2 | 
3 |    test("just throw") :- throw("some error occurred").
4 | 
5 | :- end_tests(throw).
6 | 
7 | 


--------------------------------------------------------------------------------
/compiling/jars/hamcrest-2.2.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/compiling/jars/hamcrest-2.2.jar


--------------------------------------------------------------------------------
/compiling/jars/junit-4.13.2.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/compiling/jars/junit-4.13.2.jar


--------------------------------------------------------------------------------
/compiling/logic.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # %COPYMARK%
 4 | 
 5 | # ---
 6 | # This script is copied into /etc/profile.d so that it is run whenever bash
 7 | # is started. It extends the PATH with the bin directory of the (current)
 8 | # SWI-Prolog distribution (found in /usr/local/logic/swipl in this case)
 9 | # and also sets the SWIPL_HOME environment variable.
10 | #
11 | # Additionally, it sets the path to "clingo" (the Potsdam ASP Solver) if it exists
12 | # ---
13 | 
14 | # ---
15 | # /usr/local/logic/swipl is the directory into which my self-compiled
16 | # SWI-Prolog has been installed.
17 | #
18 | # The corresponding RPM package "pl" that comes with Fedora distributes
19 | # files over the filetree. On 2021-04-21 the package "pl" is at 8.2.4
20 | # whereas devel version of SWI-Prolog is at 8.3.24
21 | #
22 | # $ dnf info pl
23 | # pl.x86_64 : SWI-Prolog - Edinburgh compatible Prolog compiler
24 | # ---
25 | 
26 | function extendPath_swipl {
27 |    local SWIPL="/usr/local/logic/swipl"
28 |    local BIN="${SWIPL}/bin"
29 |    if [[ -d "${BIN}" ]]; then
30 |       export PATH="${BIN}:${PATH}"
31 |       export SWIPL_HOME="$SWIPL"
32 |    fi
33 | }
34 | 
35 | function extendPath_clingo {
36 |    local CLINGO="/usr/local/logic/clingo"
37 |    local BIN="${CLINGO}"
38 |    if [[ -d "${BIN}" ]]; then
39 |       export PATH="${BIN}:${PATH}"
40 |    fi
41 | }
42 | 
43 | extendPath_swipl
44 | # extendPath_clingo
45 | 
46 | unset extendPath_swipl
47 | unset extendPath_clingo
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/foreign_interface_trial/sayhellolib/build.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Additional options can be passed to the compiler by adding a 
 4 | # line like this (sic):
 5 | #
 6 | # -cc-options,-std=gnu2x \
 7 | 
 8 | object="sayhellolib.so"
 9 | source="sayhellolib.c"
10 | 
11 | object_dir="lib"
12 | source_dir="src"
13 | 
14 | from_source="$source_dir/$source"
15 | to_object="$object_dir/$object"
16 | 
17 | if [[ ! -f "$from_source" ]]; then
18 |    echo "Source '$from_source' does not exist -- exiting" >&2
19 |    exit 1
20 | fi
21 | 
22 | if [[ ! -d "$object_dir" ]]; then
23 |    echo "Target directory '$object_dir' does not exist -- exiting" >&2
24 |    exit 1
25 | fi
26 | 
27 | swipl-ld \
28 |   -v \
29 |   -shared \
30 |   -o "$to_object" \
31 |   "$from_source"
32 | 
33 | # Print symbols for fun
34 | 
35 | nm "$to_object" 
36 | 


--------------------------------------------------------------------------------
/foreign_interface_trial/sayhellolib/mod/sayhellolib.pl:
--------------------------------------------------------------------------------
 1 | % ===
 2 | % sayhellolib.pl
 3 | % ===
 4 | 
 5 | :- module(sayhellolib, 
 6 |           [ 
 7 |           say_hello/2
 8 |           ]).
 9 | 
10 | :- use_foreign_library(foreign(sayhellolib)).
11 | 


--------------------------------------------------------------------------------
/in_progress/blah/template programming.txt:
--------------------------------------------------------------------------------
 1 | Is it template programming instead of logic programming?
 2 | 
 3 | atom(X) - Can you give me a template?
 4 | atom(X) - Is this template acceptable?
 5 | 
 6 | a predicate is a template generator!
 7 | 
 8 | member(X,L) is true if (iff) X is an element of the list L
 9 | 
10 | ?- open("/tmp/xxx",'write',X),ground(X).
11 | X = <stream>(0x1379cf0).
12 | 
13 | X --+--> freshvar
14 |     |
15 |     +--> nonvar --+--> ground    (totally concrete (within limits, e.g. what is a stream id ground??)
16 |                   | 
17 |                   +--> nonground (contains vars)
18 |                   
19 | Inside of member:
20 | 
21 | member(X,L) is true if (iff) X unifies with an element of a list prefix of L
22 | 
23 | 
24 | member2(X, [X|_]).
25 | member2(X, [_|Es]) :- member(X, Es).
26 | 
27 | 


--------------------------------------------------------------------------------
/in_progress/exploring/exploring_chr/test_chr.pl:
--------------------------------------------------------------------------------
 1 | :- module(my_test,[a/2]).
 2 | :- use_module(library(chr)).
 3 | 
 4 | :- chr_constraint a/2, b/1, c/1.
 5 | 
 6 | % ------------
 7 | % CHR
 8 | % ------------
 9 | 
10 | rule_1 @ a(X,1) <=> in1(X) | b(X) , out1(X).
11 | rule_2 @ a(X,2) <=> in2(X) | c(X) , out2(X).
12 | rule_3 @ b(X) <=> in3(X) | memberchk(X,[1,2]), out3(X).
13 | rule_4 @ c(X) <=> in4(X) | memberchk(X,[u,v]), out4(X).
14 | 
15 | % ------------
16 | % Prolog called by CHR
17 | % ------------
18 | 
19 | in1(X) :- format("rule_1 called : a(~q,1) <=> b(~q)\n",[X,X]). 
20 | in2(X) :- format("rule_2 called : a(~q,2) <=> c(~q)\n",[X,X]). 
21 | in3(X) :- format("rule_3 called : b(~q) <=> ~q=1\n",[X,X]). 
22 | in4(X) :- format("rule_4 called : c(~q) <=> ~q=2\n",[X,X]). 
23 | 
24 | out1(X) :- format("rule_1 success with X=~q\n",[X]). 
25 | out2(X) :- format("rule_2 success with X=~q\n",[X]). 
26 | out3(X) :- format("rule_3 success with X=~q\n",[X]). 
27 | out4(X) :- format("rule_4 success with X=~q\n",[X]). 
28 | 
29 | 
30 | 


--------------------------------------------------------------------------------
/in_progress/exploring/exploring_jpl/JNI_links.md:
--------------------------------------------------------------------------------
 1 | Thw whole manual
 2 | 
 3 | - [Java Native Interface Specification Contents](https://docs.oracle.com/en/java/javase/14/docs/specs/jni/) (Java 14)
 4 | 
 5 | Specific headings
 6 | 
 7 | - [Chapter 4: JNI Functions](https://docs.oracle.com/en/java/javase/14/docs/specs/jni/functions.html)
 8 | - [FindClass method](https://docs.oracle.com/en/java/javase/14/docs/specs/jni/functions.html#findclass)
 9 | 
10 | SWI-Prolog JPL page
11 | 
12 | [JPL](https://eu.swi-prolog.org/pldoc/doc_for?object=section(%27packages/jpl.html%27))
13 | 
14 | The canonical documentation site is http://jpl7.org/ "which subsumes the wiki".
15 | 
16 | The pointers given at the top of the page need to be swapped.
17 | 
18 | https://docs.oracle.com/en/java/javase/14/docs/specs/jni/types.html
19 | 
20 | The following should not happen:
21 | 
22 | The JPL module regards SWI Prolog strings as lists. Use atoms instead:
23 | 
24 | ```
25 | ?- jpl_call('java.lang.System','getProperty',["java.version"],V).
26 | ERROR: Type error: `method_params' expected, found `["java.version"]' (a list) (not all actual parameters are convertible to Java values or references)
27 | ERROR: In:
28 | ERROR:   [11] throw(error(type_error(method_params,...),context(...,'not all actual parameters are convertible to Java values or references')))
29 | ERROR:   [10] jpl:jpl_call('java.lang.System',getProperty,["java.version"],_23222) at /usr/local/logic/swipl/lib/swipl/library/jpl.pl:307
30 | ERROR:    [9] <user>
31 | ```
32 | 
33 | 


--------------------------------------------------------------------------------
/in_progress/exploring/exploring_jpl/connect_to_libreoffice/FirstUnoContact.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/in_progress/exploring/exploring_jpl/connect_to_libreoffice/FirstUnoContact.class


--------------------------------------------------------------------------------
/in_progress/exploring/exploring_jpl/connect_to_libreoffice/first_uno_contact.pl:
--------------------------------------------------------------------------------
 1 | :- consult('helpers/write_class_inheritance.pl').
 2 | 
 3 | jpl_class_to_raw_classname(Cobj, CN) :-
 4 |     jpl_classname_to_class('java.lang.Class', CC),      % cached?
 5 |     % https://docs.oracle.com/javase/7/docs/api/java/lang/Class.html#getName()
 6 |     jGetMethodID(CC, getName, method([],class([java,lang],['String'])), MIDgetName),
 7 |     jCallObjectMethod(Cobj, MIDgetName, [], [], S),
 8 |     S = CN.
 9 | 
10 | 
11 | first_uno_contact :-
12 |     use_module(library(jpl)),  % SWI-Prolog: use_module/1 in predicate role, as the God of Logic Programming intended
13 |     % XComponentContext is an interface!
14 |     % Java: com.sun.star.uno.XComponentContext xContext = com.sun.star.comp.helper.Bootstrap.bootstrap();
15 |     jpl_call('com.sun.star.comp.helper.Bootstrap','bootstrap',[],XContext),
16 |     format("Connected to a running office with XContext = ~q\n",[XContext]),
17 |     (jpl_is_object(XContext) -> format("XContext is an object\n") ; format("XContext is NOT an object\n")),
18 |     write_class_inheritance_path_of_object(XContext),        
19 |     % Java: com.sun.star.lang.XMultiComponentFactory xMCF = xContext.getServiceManager();
20 |     jpl_object_to_class(XContext,Cobj),
21 |     format("Object ~q has class ~q\n",[XContext,Cobj]),
22 |     jpl_class_to_raw_classname(Cobj, CN), 
23 |     format("Class ~q has raw classname (name of the entity)' ~q\n",[Cobj,CN]),
24 |     atom_codes(CN, CsCN),
25 | 
26 |     jpl_classname_chars_to_type(CsCN, Tr), % goes FALSE name is 'com.sun.proxy.$Proxy1'
27 | 
28 |     format("Classname ~q gives type ~q\n",[Cs,Tr]),
29 |  
30 |     %jpl_type_to_canonical_type(Tr, Tx),      
31 | 
32 | 
33 |     (jpl_object_to_type(XContext,Type) -> format("~q is of type ~q\n",[XContext,Type]) ; format("~q has no type!\n",[XContext])).
34 | 
35 | 
36 |   jpl_type_bare_classname(class(Ps,Cs)) -->
37 |     jpl_type_dotted_package_parts(Ps), jpl_type_class_parts(Cs). 
38 | 


--------------------------------------------------------------------------------
/in_progress/exploring/exploring_jpl/connect_to_libreoffice/helpers/write_class_inheritance.pl:
--------------------------------------------------------------------------------
 1 | % ===
 2 | % Given the reference to a Java Object, write the Java Object's
 3 | % class inheritance path out
 4 | % ===
 5 |    
 6 | write_class_inheritance_path_of_object(JObj) :- 
 7 |     assertion(jpl_is_object(JObj)),
 8 |     jpl_object_to_class(JObj, JClass),
 9 |     format("Object is of Class ~q\n",[JClass]),
10 |     write_class_inheritance_path(JClass).
11 |     
12 | write_class_inheritance_path(JX) :-     
13 |     %
14 |     % it's an Object of type java.lang.Class
15 |     %
16 |     assertion(jpl_is_object(JX)), 
17 |     assertion((jpl_object_to_class(JX,JXClass),jpl_class_to_classname(JXClass,'java.lang.Class'))),
18 |     %
19 |     % print current class name
20 |     %
21 |     jpl_class_to_classname(JX, ClassName),
22 |     format("Class ~q has name ~q\n",[JX,ClassName]),
23 |     %
24 |     % move to parent if it exists 
25 |     %
26 |     jpl_call(JX,'getSuperclass',[],JSuperClass),
27 |     (jpl_null(JSuperClass) -> true ; write_class_inheritance_path(JSuperClass)).
28 |     
29 | 


--------------------------------------------------------------------------------
/in_progress/exploring/exploring_jpl/connect_to_libreoffice/setup.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Getting JPL to work and connect to LibreOffice 
 4 | 
 5 | # Set up variables using the script that comes with LibreOffice
 6 | 
 7 | source /usr/lib64/libreoffice/sdk/setsdkenv_unix.sh
 8 | 
 9 | # The above resets to the default JDK. Therefore:
10 | 
11 | export JAVA_HOME=/usr/local/java/jdk8_64_adopt
12 | export PATH=$JAVA_HOME/bin:$PATH
13 | 
14 | # Avoid the mysterious error "no office executable found!"
15 |  
16 | # com.sun.star.comp.helper.BootstrapException: no office executable found!
17 | #          at com.sun.star.comp.helper.Bootstrap.bootstrap(Bootstrap.java:338)
18 | #          at com.sun.star.comp.helper.Bootstrap.bootstrap(Bootstrap.java:302)
19 | #          at FirstUnoContact.main(FirstUnoContact.java:42)
20 | 
21 | # Code inspection shows that ridljar/com/sun/star/comp/helper/Bootstrap.java
22 | # looks for a resource "soffice" or "soffice.exe". This means:
23 | 
24 | export CLASSPATH=/usr/lib64/libreoffice/program/:$CLASSPATH
25 | 
26 | # ---
27 | # Java programs
28 | # ---
29 | 
30 | # javac FirstUnoContact.java & java FirstUnoContact
31 | 
32 | 
33 | 


--------------------------------------------------------------------------------
/in_progress/exploring/exploring_jpl/connect_to_libreoffice/tests/test_gregorian_calendar.pl:
--------------------------------------------------------------------------------
 1 | :- consult('helpers/write_class_inheritance.pl').
 2 |    
 3 | % ===
 4 | % A Gregorian Calendar stays a Gregorian Calendar
 5 | % ===
 6 | 
 7 | simple(cal) :-
 8 |     use_module(library(jpl)),
 9 |     jpl_new('java.util.GregorianCalendar',[],JGC),
10 |     format("Obtained Java GregorianCalendar = ~q\n",[JGC]),
11 |     (jpl_is_object(JGC) -> format("JGC is an object\n") ; (format("JGC is NOT an object\n"),fail)),
12 |     write_class_inheritance_path_of_object(JGC).
13 |     
14 | 


--------------------------------------------------------------------------------
/in_progress/exploring/exploring_jpl/connect_to_libreoffice/tests/test_java_string.pl:
--------------------------------------------------------------------------------
 1 | :- consult('helpers/write_class_inheritance.pl').
 2 | 
 3 | % ===
 4 | % A Java String is Prologified into an atom
 5 | % ===
 6 | 
 7 | simple(str) :-
 8 |     use_module(library(jpl)),
 9 |     jpl_new('java.lang.String',['Hello, World'],JS),
10 |     format("Obtained Java String = ~q\n",[JS]),
11 |     (jpl_is_object(JS) -> format("JS is an object\n") ; format("JS is NOT an object\n")),
12 |     (atom(JS) -> format("JS is an atom\n") ; format("JS is NOT an atom\n")).
13 |     
14 | 


--------------------------------------------------------------------------------
/in_progress/exploring/exploring_jpl/java_classname_parsing/jpl.pl:
--------------------------------------------------------------------------------
1 | /usr/local/logic/swipl/lib/swipl/library/jpl.pl


--------------------------------------------------------------------------------
/in_progress/library_aggregate/mtcars_help.pl:
--------------------------------------------------------------------------------
 1 | % Backtrackable predicates that get certain values for each car.
 2 | % In relational theory, these are projections (but they keep the duplicates)
 3 | 
 4 | car_name_mpg(Name,Mpg) :- mtcars(L),memberchk(name(Name),L),memberchk(mpg(Mpg),L).
 5 | car_name_cyl(Name,Cyl) :- mtcars(L),memberchk(name(Name),L),memberchk(cyl(Cyl),L).
 6 | car_cyl_mpg(Cyl,Mpg)   :- mtcars(L),memberchk(mpg(Mpg),L),memberchk(cyl(Cyl),L).
 7 | 
 8 | % Examine the result of the aggregate predicates, which have varying type
 9 | 
10 | unpump(X) :- is_list(X),!,length(X,LL),format("Result: a list of length ~w\n",LL).
11 | unpump(X) :- number(X),!,format("Result: the value ~w\n",X).
12 | 
13 | 


--------------------------------------------------------------------------------
/in_progress/on_dif.md:
--------------------------------------------------------------------------------
 1 | # Based on a note by Peter Ludemann
 2 | 
 3 | [Note](https://swi-prolog.discourse.group/t/friday-afternoon-post-a-quick-diagram-of-the-lp-landscape/1976/11?u=dtonhofer)
 4 | 
 5 | MU-Prolog and NU-Prolog [both from Melbourne University 1980s], took the position of “delay computing the negation until there’s
 6 | sufficient information for it to be sound.” 
 7 | 
 8 | Swipl’s [`dif/2`](https://www.swi-prolog.org/pldoc/doc_for?object=dif/2) 1 is an example of doing that.
 9 | 
10 | This example might help.
11 | 
12 | - Query #1 gives a wrong result because `\=/2` was evaluated before `X` and `Y` were sufficiently ground.
13 | 
14 | ```
15 | 1 ?- X \= Y, X = 1, Y = 2.
16 | false.
17 | ```
18 | - Query #2 is correct – `dif/2` is the same as `\=/2`, delayed until enough is known about the arguments to
19 | give a correct answer.
20 | 
21 | ```
22 | 2 ?- dif(X, Y), X = 1, Y = 2.
23 | X = 1,
24 | Y = 2.
25 | ```
26 | 
27 | ```
28 | 3 ?- freeze(X, freeze(Y, X \= Y)), X = 1, Y = 2.
29 | X = 1,
30 | Y = 2.
31 | ```
32 | 
33 | Query #3 has too weak a delay condition:
34 | 
35 | ```
36 | 4 ?- freeze(X, freeze(Y, X \= Y)), X = f(A), Y = f(B), A = 1, B = 2.
37 | false.
38 | ```
39 | 
40 | ```
41 | 5 ?- dif(X, Y), X = f(A), Y = f(B), A = 1, B = 2.
42 | X = f(1),
43 | Y = f(2),
44 | A = 1,
45 | B = 2.
46 | ```
47 | 
48 | 


--------------------------------------------------------------------------------
/in_progress/pldoc_trick.md:
--------------------------------------------------------------------------------
 1 | In `${SWIPL_HOME}/lib/swipl/library/pldoc.pl`
 2 | 
 3 | ````
 4 | :- module(pldoc,
 5 |           [ doc_collect/1,              % +Bool
 6 |             pldoc_loading/0             % True if we are loading
 7 |           ]).
 8 |           
 9 | :- dynamic
10 |     pldoc_loading/0.
11 | 
12 | pldoc_loading.
13 | ````
14 | 
15 | ... code, and at the end:
16 | 
17 | ````
18 | %!  pldoc_loading is semidet.
19 | %
20 | %   True if we are loading the  PlDoc libraries. Required internally
21 | %   to avoid undefined predicates  while   re-loading  and  document
22 | %   itself.
23 | 
24 | 
25 |                  /*******************************
26 |                  *           FINISH UP          *
27 |                  *******************************/
28 | 
29 | :- retract(pldoc_loading).
30 | ````
31 | 
32 | _semidet_ means "succeed at most once"
33 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/ConnectTest.java:
--------------------------------------------------------------------------------
1 | src/test/java/name/heavycarbon/jpl/callprolog/ConnectTest.java


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/jars/jpl.jar:
--------------------------------------------------------------------------------
1 | /usr/local/logic/swiplexe_8.3.7/lib/swipl/lib/jpl.jar


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/jars/junitsl.jar:
--------------------------------------------------------------------------------
1 | /home/calvin/.m2/repository/org/junit/platform/junit-platform-console-standalone/1.7.0/junit-platform-console-standalone-1.7.0.jar


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/jars/logback-classic.jar:
--------------------------------------------------------------------------------
1 | /home/calvin/.m2/repository/ch/qos/logback/logback-classic/1.3.0-alpha5/logback-classic-1.3.0-alpha5.jar


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/jars/logback-core.jar:
--------------------------------------------------------------------------------
1 | /home/calvin/.m2/repository/ch/qos/logback/logback-core/1.3.0-alpha5/logback-core-1.3.0-alpha5.jar


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/jars/slf4j-api.jar:
--------------------------------------------------------------------------------
1 | /home/calvin/.m2/repository/org/slf4j/slf4j-api/2.0.0-alpha1/slf4j-api-2.0.0-alpha1.jar


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/element-list:
--------------------------------------------------------------------------------
1 | org.jpl7
2 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE HTML>
 2 | <!-- NewPage -->
 3 | <html lang="en">
 4 | <head>
 5 | <!-- Generated by javadoc (14.0.1) on Sat Sep 26 00:44:20 CEST 2020 -->
 6 | <title>Generated Documentation (Untitled)</title>
 7 | <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 8 | <meta name="dc.created" content="2020-09-26">
 9 | <meta name="description" content="index redirect">
10 | <meta name="generator" content="javadoc/IndexRedirectWriter">
11 | <link rel="canonical" href="org/jpl7/package-summary.html">
12 | <link rel="stylesheet" type="text/css" href="stylesheet.css" title="Style">
13 | <script type="text/javascript">window.location.replace('org/jpl7/package-summary.html')</script>
14 | <noscript>
15 | <meta http-equiv="Refresh" content="0;org/jpl7/package-summary.html">
16 | </noscript>
17 | </head>
18 | <body class="index-redirect">
19 | <main role="main">
20 | <noscript>
21 | <p>JavaScript is disabled on your browser.</p>
22 | </noscript>
23 | <p><a href="org/jpl7/package-summary.html">org/jpl7/package-summary.html</a></p>
24 | </main>
25 | </body>
26 | </html>
27 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/member-search-index.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/member-search-index.zip


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/package-search-index.js:
--------------------------------------------------------------------------------
1 | packageSearchIndex = [{"l":"All Packages","url":"allpackages-index.html"},{"l":"org.jpl7"}]


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/package-search-index.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/package-search-index.zip


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/resources/glass.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/resources/glass.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/resources/x.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/resources/x.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-bg_glass_55_fbf9ee_1x400.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-bg_glass_55_fbf9ee_1x400.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-bg_glass_65_dadada_1x400.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-bg_glass_65_dadada_1x400.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-bg_glass_75_dadada_1x400.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-bg_glass_75_dadada_1x400.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-bg_glass_75_e6e6e6_1x400.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-bg_glass_75_e6e6e6_1x400.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-bg_glass_95_fef1ec_1x400.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-bg_glass_95_fef1ec_1x400.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-bg_highlight-soft_75_cccccc_1x100.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-bg_highlight-soft_75_cccccc_1x100.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-icons_222222_256x240.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-icons_222222_256x240.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-icons_2e83ff_256x240.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-icons_2e83ff_256x240.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-icons_454545_256x240.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-icons_454545_256x240.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-icons_888888_256x240.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-icons_888888_256x240.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-icons_cd0a0a_256x240.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/images/ui-icons_cd0a0a_256x240.png


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/jquery-ui.structure.min.css:
--------------------------------------------------------------------------------
1 | /*! jQuery UI - v1.12.1 - 2018-12-06
2 | * http://jqueryui.com
3 | * Copyright jQuery Foundation and other contributors; Licensed MIT */
4 | 
5 | .ui-helper-hidden{display:none}.ui-helper-hidden-accessible{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.ui-helper-reset{margin:0;padding:0;border:0;outline:0;line-height:1.3;text-decoration:none;font-size:100%;list-style:none}.ui-helper-clearfix:before,.ui-helper-clearfix:after{content:"";display:table;border-collapse:collapse}.ui-helper-clearfix:after{clear:both}.ui-helper-zfix{width:100%;height:100%;top:0;left:0;position:absolute;opacity:0;filter:Alpha(Opacity=0)}.ui-front{z-index:100}.ui-state-disabled{cursor:default!important;pointer-events:none}.ui-icon{display:inline-block;vertical-align:middle;margin-top:-.25em;position:relative;text-indent:-99999px;overflow:hidden;background-repeat:no-repeat}.ui-widget-icon-block{left:50%;margin-left:-8px;display:block}.ui-widget-overlay{position:fixed;top:0;left:0;width:100%;height:100%}.ui-autocomplete{position:absolute;top:0;left:0;cursor:default}.ui-menu{list-style:none;padding:0;margin:0;display:block;outline:0}.ui-menu .ui-menu{position:absolute}.ui-menu .ui-menu-item{margin:0;cursor:pointer;list-style-image:url("data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7")}.ui-menu .ui-menu-item-wrapper{position:relative;padding:3px 1em 3px .4em}.ui-menu .ui-menu-divider{margin:5px 0;height:0;font-size:0;line-height:0;border-width:1px 0 0 0}.ui-menu .ui-state-focus,.ui-menu .ui-state-active{margin:-1px}.ui-menu-icons{position:relative}.ui-menu-icons .ui-menu-item-wrapper{padding-left:2em}.ui-menu .ui-icon{position:absolute;top:0;bottom:0;left:.2em;margin:auto 0}.ui-menu .ui-menu-icon{left:auto;right:0}


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/jszip-utils/dist/jszip-utils-ie.min.js:
--------------------------------------------------------------------------------
 1 | /*!
 2 | 
 3 | JSZipUtils - A collection of cross-browser utilities to go along with JSZip.
 4 | <http://stuk.github.io/jszip-utils>
 5 | 
 6 | (c) 2014 Stuart Knightley, David Duponchel
 7 | Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/jszip-utils/master/LICENSE.markdown.
 8 | 
 9 | */
10 | !function a(b,c,d){function e(g,h){if(!c[g]){if(!b[g]){var i="function"==typeof require&&require;if(!h&&i)return i(g,!0);if(f)return f(g,!0);throw new Error("Cannot find module '"+g+"'")}var j=c[g]={exports:{}};b[g][0].call(j.exports,function(a){var c=b[g][1][a];return e(c?c:a)},j,j.exports,a,b,c,d)}return c[g].exports}for(var f="function"==typeof require&&require,g=0;g<d.length;g++)e(d[g]);return e}({1:[function(){var a="undefined"!=typeof self?self:"undefined"!=typeof window?window:{},b="<!-- IEBinaryToArray_ByteStr -->\r\n<script type='text/vbscript'>\r\nFunction IEBinaryToArray_ByteStr(Binary)\r\n   IEBinaryToArray_ByteStr = CStr(Binary)\r\nEnd Function\r\nFunction IEBinaryToArray_ByteStr_Last(Binary)\r\n   Dim lastIndex\r\n   lastIndex = LenB(Binary)\r\n   if lastIndex mod 2 Then\r\n       IEBinaryToArray_ByteStr_Last = Chr( AscB( MidB( Binary, lastIndex, 1 ) ) )\r\n   Else\r\n       IEBinaryToArray_ByteStr_Last = \"\"\r\n   End If\r\nEnd Function\r\n</script>\r\n";document.write(b),a.JSZipUtils._getBinaryFromXHR=function(a){for(var b=a.responseBody,c={},d=0;256>d;d++)for(var e=0;256>e;e++)c[String.fromCharCode(d+(e<<8))]=String.fromCharCode(d)+String.fromCharCode(e);var f=IEBinaryToArray_ByteStr(b),g=IEBinaryToArray_ByteStr_Last(b);return f.replace(/[\s\S]/g,function(a){return c[a]})+g}},{}]},{},[1]);
11 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/script-dir/jszip-utils/dist/jszip-utils.min.js:
--------------------------------------------------------------------------------
 1 | /*!
 2 | 
 3 | JSZipUtils - A collection of cross-browser utilities to go along with JSZip.
 4 | <http://stuk.github.io/jszip-utils>
 5 | 
 6 | (c) 2014 Stuart Knightley, David Duponchel
 7 | Dual licenced under the MIT license or GPLv3. See https://raw.github.com/Stuk/jszip-utils/master/LICENSE.markdown.
 8 | 
 9 | */
10 | !function(a){"object"==typeof exports?module.exports=a():"function"==typeof define&&define.amd?define(a):"undefined"!=typeof window?window.JSZipUtils=a():"undefined"!=typeof global?global.JSZipUtils=a():"undefined"!=typeof self&&(self.JSZipUtils=a())}(function(){return function a(b,c,d){function e(g,h){if(!c[g]){if(!b[g]){var i="function"==typeof require&&require;if(!h&&i)return i(g,!0);if(f)return f(g,!0);throw new Error("Cannot find module '"+g+"'")}var j=c[g]={exports:{}};b[g][0].call(j.exports,function(a){var c=b[g][1][a];return e(c?c:a)},j,j.exports,a,b,c,d)}return c[g].exports}for(var f="function"==typeof require&&require,g=0;g<d.length;g++)e(d[g]);return e}({1:[function(a,b){"use strict";function c(){try{return new window.XMLHttpRequest}catch(a){}}function d(){try{return new window.ActiveXObject("Microsoft.XMLHTTP")}catch(a){}}var e={};e._getBinaryFromXHR=function(a){return a.response||a.responseText};var f=window.ActiveXObject?function(){return c()||d()}:c;e.getBinaryContent=function(a,b){try{var c=f();c.open("GET",a,!0),"responseType"in c&&(c.responseType="arraybuffer"),c.overrideMimeType&&c.overrideMimeType("text/plain; charset=x-user-defined"),c.onreadystatechange=function(){var d,f;if(4===c.readyState)if(200===c.status||0===c.status){d=null,f=null;try{d=e._getBinaryFromXHR(c)}catch(g){f=new Error(g)}b(f,d)}else b(new Error("Ajax error for "+a+" : "+this.status+" "+this.statusText),null)},c.send()}catch(d){b(new Error(d),null)}},b.exports=e},{}]},{},[1])(1)});
11 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/type-search-index.js:
--------------------------------------------------------------------------------
1 | typeSearchIndex = [{"l":"All Classes","url":"allclasses-index.html"},{"p":"org.jpl7","l":"Atom"},{"p":"org.jpl7","l":"Compound"},{"p":"org.jpl7","l":"Dict"},{"p":"org.jpl7","l":"Float"},{"p":"org.jpl7","l":"Integer"},{"p":"org.jpl7","l":"JPL"},{"p":"org.jpl7","l":"JPLException"},{"p":"org.jpl7","l":"JRef"},{"p":"org.jpl7","l":"PrologException"},{"p":"org.jpl7","l":"Query"},{"p":"org.jpl7","l":"Rational"},{"p":"org.jpl7","l":"Term"},{"p":"org.jpl7","l":"Util"},{"p":"org.jpl7","l":"Variable"}]


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/type-search-index.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/javadoc/type-search-index.zip


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/javasrc:
--------------------------------------------------------------------------------
1 | /home/calvin/Development/swiplmaking/swiplmaking7/jpl/packages-jpl_forked/src/main/java/


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/jpl7:
--------------------------------------------------------------------------------
1 | /home/calvin/Development/swiplmaking/swiplmaking7/jpl/packages-jpl_forked/src/main/java/org/jpl7/


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/make_javadoc.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | here=$(dirname "$0")
 4 | 
 5 | javadocs="$here/javadocs"
 6 | 
 7 | cd "$javadocs" || {
 8 |    echo "Could not cd to directory 'javadocs' -- exiting" >&2
 9 |    exit 1
10 | }
11 | 
12 | javadoc -sourcepath ../javasrc/ org.jpl7
13 | 
14 | 
15 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/original_tests:
--------------------------------------------------------------------------------
1 | /home/calvin/Development/swiplmaking/swiplmaking7/jpl/packages-jpl_forked/src/test/java/org


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/src/main/java/name/heavycarbon/jpl/callprolog/Connect.java:
--------------------------------------------------------------------------------
 1 | package name.heavycarbon.jpl.callprolog;
 2 | 
 3 | public class Connect 
 4 | {
 5 |     public static void main( String[] args )
 6 |     {
 7 |         System.out.println( "Hello World!" );
 8 |     }
 9 | }
10 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/src/test/java/name/heavycarbon/jpl/callprolog/ConnectTest.java:
--------------------------------------------------------------------------------
 1 | package name.heavycarbon.jpl.callprolog;
 2 | 
 3 | import static org.junit.Assert.*;
 4 | import org.junit.Test;
 5 | import org.slf4j.Logger;
 6 | import org.slf4j.LoggerFactory;
 7 | import org.jpl7.JPL;
 8 | 
 9 | public class ConnectTest {
10 | 
11 |     @Test
12 |     public void gettingSettingDefaultInitArgs() {
13 |        Logger logger = LoggerFactory.getLogger("gettingSettingDefaultInitArgs");
14 |        // String[] initArgs = JPL.getActualInitArgs(); // returns null if not yet initialized
15 |        String[] initArgs = JPL.getDefaultInitArgs(); // returns null if not yet initialized
16 |        for (String str : initArgs) {
17 |           logger.info("Found {}",str);
18 |        }
19 |     }
20 | 
21 | }
22 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/target/classes/name/heavycarbon/jpl/callprolog/Connect.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/target/classes/name/heavycarbon/jpl/callprolog/Connect.class


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst:
--------------------------------------------------------------------------------
1 | name/heavycarbon/jpl/callprolog/Connect.class
2 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst:
--------------------------------------------------------------------------------
1 | /home/calvin/Development/_WORK_ON_PROLOG/github/prolog_notes/calling_from_java/callprolog/src/main/java/name/heavycarbon/jpl/callprolog/Connect.java
2 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/createdFiles.lst:
--------------------------------------------------------------------------------
1 | name/heavycarbon/jpl/callprolog/ConnectTest.class
2 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst:
--------------------------------------------------------------------------------
1 | /home/calvin/Development/_WORK_ON_PROLOG/github/prolog_notes/calling_from_java/callprolog/src/test/java/name/heavycarbon/jpl/callprolog/ConnectTest.java
2 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/target/surefire-reports/name.heavycarbon.jpl.callprolog.ConnectTest.txt:
--------------------------------------------------------------------------------
1 | -------------------------------------------------------------------------------
2 | Test set: name.heavycarbon.jpl.callprolog.ConnectTest
3 | -------------------------------------------------------------------------------
4 | Tests run: 1, Failures: 0, Errors: 1, Skipped: 0, Time elapsed: 0.124 s <<< FAILURE! - in name.heavycarbon.jpl.callprolog.ConnectTest
5 | name.heavycarbon.jpl.callprolog.ConnectTest.gettingSettingDefaultInitArgs  Time elapsed: 0.106 s  <<< ERROR!
6 | java.lang.UnsatisfiedLinkError: no jpl in java.library.path: [/usr/java/packages/lib, /usr/lib64, /lib64, /lib, /usr/lib]
7 | 	at name.heavycarbon.jpl.callprolog.ConnectTest.gettingSettingDefaultInitArgs(ConnectTest.java:15)
8 | 
9 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/calling_from_java/callprolog/target/test-classes/name/heavycarbon/jpl/callprolog/ConnectTest.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/calling_from_java/callprolog/target/test-classes/name/heavycarbon/jpl/callprolog/ConnectTest.class


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/code_jpl/java_classname_dcg_for_jpl/java_tooling/PrintSomeEntityNames.java:
--------------------------------------------------------------------------------
 1 | class PrintSomeEntityNames {
 2 |    public static final void main(String[] argv) {
 3 | 
 4 |       System.out.println(void.class.getName());        // void
 5 |       System.out.println(Void.TYPE.getName());         // void
 6 |       System.out.println(Void.class.getName());        // java.lang.Void
 7 | 
 8 |       System.out.println(char.class.getName());        // char 
 9 |       System.out.println(Character.TYPE.getName());    // char
10 |       System.out.println(Character.class.getName());   // java.lang.Character
11 |       System.out.println(Character.valueOf('x').getClass().getName());  // java.lang.Character
12 | 
13 |       System.out.println(int[].class.getName());                               // [I
14 |       System.out.println((new int[4]).getClass().getName());                   // [I
15 |       int[] a = {1,2,3}; System.out.println(a.getClass().getName());           // [I
16 |  
17 |       System.out.println(int[][].class.getName());                             // [[I
18 |       System.out.println((new int[4][4]).getClass().getName());                // [[I
19 |       int[][] aa = {{1},{2},{3}}; System.out.println(aa.getClass().getName()); // [[I
20 | 
21 |       System.out.println(Integer[][].class.getName());                             // [[Ljava.lang.Integer;
22 |       System.out.println((new Integer[4][4]).getClass().getName());                // [[Ljava.lang.Integer;
23 |       Integer[][] bb = {{1},{2},{3}}; System.out.println(bb.getClass().getName()); // [[Ljava.lang.Integer;
24 | 
25 |    }
26 | }
27 | 
28 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/code_jpl/java_classname_dcg_for_jpl/java_tooling/TestPrintPrimitives.java:
--------------------------------------------------------------------------------
 1 | class TestPrintPrimitives {
 2 |    
 3 |    public static void main(String[] argv) {
 4 |        System.out.println(boolean.class.getName());
 5 |        System.out.println(Boolean.class.getName());
 6 |        System.out.println(byte.class.getName());
 7 |        System.out.println(Byte.class.getName());
 8 |        System.out.println(char.class.getName());
 9 |        System.out.println(Character.class.getName());
10 |        System.out.println(double.class.getName());
11 |        System.out.println(Double.class.getName());
12 |        System.out.println(float.class.getName());
13 |        System.out.println(Float.class.getName());
14 |        System.out.println(int.class.getName());
15 |        // System.out.println(integer.class.getName()); does not exist but *could* be a user-defined class
16 |        System.out.println(Integer.class.getName());
17 |        System.out.println(long.class.getName());
18 |        System.out.println(Long.class.getName());
19 |        System.out.println(short.class.getName());
20 |        System.out.println(Short.class.getName());
21 |        System.out.println(void.class.getName());
22 |        System.out.println(Void.class.getName());
23 |     }
24 | }
25 | 
26 | /* 
27 | 
28 | Which outputs:
29 | 
30 |  boolean
31 |  java.lang.Boolean
32 |  byte
33 |  java.lang.Byte
34 |  char
35 |  java.lang.Character
36 |  double
37 |  java.lang.Double
38 |  float
39 |  java.lang.Float
40 |  int
41 |  java.lang.Integer
42 |  long
43 |  java.lang.Long
44 |  short
45 |  java.lang.Short
46 |  void
47 |  java.lang.Void
48 | 
49 | */
50 | 


--------------------------------------------------------------------------------
/jpl_java_prolog_bridge/structure_of_jpl_src/organization_in_distro.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/jpl_java_prolog_bridge/structure_of_jpl_src/organization_in_distro.png


--------------------------------------------------------------------------------
/other_notes/about_byrd_box_model/pics/byrd_box_model.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_byrd_box_model/pics/byrd_box_model.png


--------------------------------------------------------------------------------
/other_notes/about_byrd_box_model/pics/commit_rollback.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_byrd_box_model/pics/commit_rollback.png


--------------------------------------------------------------------------------
/other_notes/about_byrd_box_model/pics/original_byrd_box.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_byrd_box_model/pics/original_byrd_box.png


--------------------------------------------------------------------------------
/other_notes/about_byrd_box_model/pics/term_store_versioning.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_byrd_box_model/pics/term_store_versioning.png


--------------------------------------------------------------------------------
/other_notes/about_depicting_terms/pics/Example_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_depicting_terms/pics/Example_1.png


--------------------------------------------------------------------------------
/other_notes/about_depicting_terms/pics/Example_2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_depicting_terms/pics/Example_2.png


--------------------------------------------------------------------------------
/other_notes/about_depicting_terms/pics/Example_3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_depicting_terms/pics/Example_3.png


--------------------------------------------------------------------------------
/other_notes/about_depicting_terms/pics/Example_Compound_Term_List.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_depicting_terms/pics/Example_Compound_Term_List.png


--------------------------------------------------------------------------------
/other_notes/about_depicting_terms/pics/Example_Compound_Term_Open_List.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_depicting_terms/pics/Example_Compound_Term_Open_List.png


--------------------------------------------------------------------------------
/other_notes/about_depicting_terms/pics/Symbols.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_depicting_terms/pics/Symbols.png


--------------------------------------------------------------------------------
/other_notes/about_depicting_terms/pics/Vocabulary.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_depicting_terms/pics/Vocabulary.png


--------------------------------------------------------------------------------
/other_notes/about_depicting_terms/pics2/prolog_term_notation.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_depicting_terms/pics2/prolog_term_notation.png


--------------------------------------------------------------------------------
/other_notes/about_depicting_terms/roles_of_terms.md:
--------------------------------------------------------------------------------
 1 | # Roles of Terms
 2 | 
 3 | Terms can appear with various Roles
 4 | 
 5 | - **Role of a Skeleton**. These are terms whose arguments are all different variables. Created by `functor/3`. 
 6 | - **Role of a Predicate**
 7 |   - Predicates of various arities, arity 0 is allowed! (as in `foo :- bar.`)    
 8 | - **Role of a Goal**, as argument to meta-predicates which call the Goal
 9 |   - **Simple Goal**: A predicate name and the parameters which which it shall be called. As in `p(X,Y,12,"Hello")`. 
10 |   - **Complex Goal**: May be a conjunction, disjunction, implication, may even include cuts.
11 |   - **Closures**: Predicates with arguments partially filled-in (filling them in from the left only): This is not
12 |     quite the same as a "closure" of functional programming. For example, if you have 
13 |     predicate `foo/5`, a corresponding closure might be `foo(1,2)`: a term indicating the name of the predicate
14 |     and its two leftmost arguments, which have to be completed to 5 arguments before a clal can be issued.  
15 |   - **Lambda Expressions**: Lambda Expressions are used to "wrap around" other predicates to make
16 |     meta-calling convenient. See: [`library(yall)`](https://www.swi-prolog.org/pldoc/man?section=yall)
17 |     - "Lambda Prolog" Lambda expressions are something else...  
18 | - **Role of an (Arithmetic) Function** 
19 |   - These appear on the right side of the `is/2^ predicate.
20 |   - Constants are atoms.
21 |   - Functions are compound terms of arity >= 1. 
22 |   - Might be of interest to have extension to allow functions other-than-arithmetic and in other places than
23 |     on the right side of `is/2`.
24 | - **Role of arbitrary data** in the form of a tree or list structure. Cyclic terms allow directed, single-rooted graphs.
25 | 
26 | 


--------------------------------------------------------------------------------
/other_notes/about_f_logic/pics/parts_of_the_isa_hierarchy.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_f_logic/pics/parts_of_the_isa_hierarchy.png


--------------------------------------------------------------------------------
/other_notes/about_fibonacci_numbers/Fibonacci.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_fibonacci_numbers/Fibonacci.png


--------------------------------------------------------------------------------
/other_notes/about_fibonacci_numbers/README.md:
--------------------------------------------------------------------------------
 1 | # Various Prolog implementations to compute numbers from the Fibonacci Series 
 2 | 
 3 | Several approaches at computing Fibonacci series in Prolog:
 4 | 
 5 | - [fibonacci_algorithms.pl](fibonacci_algorithms.pl) - Source
 6 | - [fibonacci_algorithms.plt](fibonacci_algorithms.plt) - [plunit](https://eu.swi-prolog.org/pldoc/doc_for?object=section%28%27packages/plunit.html%27%29) unit tests
 7 | 
 8 | The above has been run on SWI Prolog 8.3.9 (some SWI-Prolog specificities are in there).
 9 | 
10 | TODO: Needs performance comparison (space and time and recursion depth)
11 | 
12 | Run the tests:
13 | 
14 | ```
15 | ?- [fibonacci_algorithms],load_test_files([]),run_tests.
16 | % PL-Unit: fibonacci .......... done
17 | % All 10 tests passed
18 | true.
19 | ```
20 | 
21 | More on this number series at Wikipedia: [Fibonacci numbers](https://en.wikipedia.org/wiki/Fibonacci_number)
22 | 
23 | Here is compressed explainer in SVG (you can zoom in!), showing how the algorithms can be organized.
24 | 
25 | ![Approaches](Fibonacci.svg)
26 | 
27 | The solution that caches `(x,fib(x))` using [`assertz/1`](https://eu.swi-prolog.org/pldoc/doc_for?object=assertz/1)
28 | (as found at [Rosettacode.org](http://rosettacode.org/wiki/Fibonacci_sequence#Prolog) or
29 | [This Stack Overflow question](https://stackoverflow.com/questions/16358747/why-this-dynamic-version-of-fibonacci-program-is-incredibly-faster-then-this-oth))
30 | is not in the set of approaches because I feel doing things that way should be avoided.
31 | 


--------------------------------------------------------------------------------
/other_notes/about_fibonacci_numbers/Two entries discovered on Rosettacode which I dont get.txt:
--------------------------------------------------------------------------------
 1 | Works with SWI-Prolog and module lambda, written by Ulrich Neumerkel found there http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl
 2 | 
 3 | :- use_module(lambda).
 4 | fib(N, FN) :-
 5 | 	cont_fib(N, _, FN, \_^Y^_^U^(U = Y)).
 6 |  
 7 | cont_fib(N, FN1, FN, Pred) :-
 8 | 	(   N < 2 ->
 9 | 	    call(Pred, 0, 1, FN1, FN)
10 | 	;
11 | 	    N1 is N - 1,
12 | 	    P = \X^Y^Y^U^(U is X + Y),
13 | 	    cont_fib(N1, FNA, FNB, P),
14 | 	    call(Pred, FNA, FNB, FN1, FN)
15 | 	).
16 |  
17 | 
18 | Generators idiom
19 | 
20 | take( 0, Next, Z-Z, Next).
21 | take( N, Next, [A|B]-Z, NZ):- N>0, !, next( Next, A, Next1),
22 |   N1 is N-1,
23 |   take( N1, Next1, B-Z, NZ).
24 |  
25 | next( fib(A,B), A, fib(B,C)):- C is A+B.
26 |  
27 | %% usage: ?- take(15, fib(0,1), _X-[], G), writeln(_X).
28 | %% [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]
29 | %% G = fib(610, 987)
30 | 
31 |  
32 | 


--------------------------------------------------------------------------------
/other_notes/about_foldl_and_foldr/README.md:
--------------------------------------------------------------------------------
 1 | # Linear _foldl_ and _foldr_ in Prolog
 2 | 
 3 | **Explainer: [foldl_and_foldr.md](foldl_and_foldr.md)**
 4 | 
 5 | - Functions used in unit tests: [foldy.pl](foldy.pl)
 6 | - Linear _foldl_ implementation (with unit tests): [foo_foldl.pl](foo_foldl.pl)
 7 | - Linear _foldr_ implementation (with unit tests): [foo_foldr.pl](foo_foldr.pl)
 8 | 
 9 | And also:
10 | 
11 | - Linear _foldl_ using `maplist/4`: 
12 |    - Explainer: [linear_foldl_with_maplist4.md](linear_foldl_with_maplist4.md)
13 |    - Implementation (with unit tests). [maplist_foldl.pl](maplist_foldl.pl)
14 | 
15 | - Linear _foldl_ using DCGs:
16 |    - Implementation (with unit tests). [dcg_foldl.pl](dcg_foldl.pl)
17 | 
18 | 
19 | 
20 | 
21 | 
22 | 
23 | 	
24 | 	
25 | 	
26 | 	
27 | 	
28 | 


--------------------------------------------------------------------------------
/other_notes/about_foldl_and_foldr/foldr_for_library_apply/README.md:
--------------------------------------------------------------------------------
1 | # Experimental 
2 | 


--------------------------------------------------------------------------------
/other_notes/about_foldl_and_foldr/foo_foldx.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_foldl_and_foldr/foo_foldx.png


--------------------------------------------------------------------------------
/other_notes/about_list_processing/pics/difference_list_explainer.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_list_processing/pics/difference_list_explainer.png


--------------------------------------------------------------------------------
/other_notes/about_list_processing/pics/idioms.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_list_processing/pics/idioms.png


--------------------------------------------------------------------------------
/other_notes/about_list_processing/pics/list_processing_idioms.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_list_processing/pics/list_processing_idioms.png


--------------------------------------------------------------------------------
/other_notes/about_monads/Java Optional.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_monads/Java Optional.png


--------------------------------------------------------------------------------
/other_notes/about_negation/pics/another_graph_for_naf.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_negation/pics/another_graph_for_naf.png


--------------------------------------------------------------------------------
/other_notes/about_negation/pics/byrd_box_view_of_negation.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_negation/pics/byrd_box_view_of_negation.png


--------------------------------------------------------------------------------
/other_notes/about_negation/pics/cover_LNCS238.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_negation/pics/cover_LNCS238.jpg


--------------------------------------------------------------------------------
/other_notes/about_negation/pics/cover_LNCS764.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_negation/pics/cover_LNCS764.png


--------------------------------------------------------------------------------
/other_notes/about_negation/pics/domains_of_negation.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_negation/pics/domains_of_negation.png


--------------------------------------------------------------------------------
/other_notes/about_negation/pics/predicate_graph.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_negation/pics/predicate_graph.png


--------------------------------------------------------------------------------
/other_notes/about_negation/pics/some_extended_logical_values.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_negation/pics/some_extended_logical_values.png


--------------------------------------------------------------------------------
/other_notes/about_negation/pics/where_is_the_set_naf.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_negation/pics/where_is_the_set_naf.png


--------------------------------------------------------------------------------
/other_notes/about_rule_based_systems/README.md:
--------------------------------------------------------------------------------
 1 | # Rule-based Systems
 2 | 
 3 | A very low-fidelity overview, but one needs general maps.
 4 | 
 5 | ![Rule-based Systems](pics/fwd_and_bwd_chaining.svg)
 6 | 
 7 | This an offshoot from this question on StackOverflow: [Forward and Backward Chaining](https://stackoverflow.com/questions/62376526/forward-and-backward-chaining), which has a lot of additional information and also talks about _LPS_, the Logic-Based Production System.
 8 | 
 9 | One error is that CHR does not do backtracking (it is "commited choice" - the backtracking is provided by the calling Prolog system). To be corrected!
10 | 
11 | 
12 | 
13 | 


--------------------------------------------------------------------------------
/other_notes/about_rule_based_systems/pics/RuleML family (from RuleML Perspective on Reaction Rule Standards by Adrian Paschke).png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_rule_based_systems/pics/RuleML family (from RuleML Perspective on Reaction Rule Standards by Adrian Paschke).png


--------------------------------------------------------------------------------
/other_notes/about_rule_based_systems/pics/fwd_and_bwd_chaining.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_rule_based_systems/pics/fwd_and_bwd_chaining.png


--------------------------------------------------------------------------------
/other_notes/about_rule_based_systems/pics/one_LPS_cycle.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_rule_based_systems/pics/one_LPS_cycle.png


--------------------------------------------------------------------------------
/other_notes/about_rule_based_systems/pics/reactive_rule_fire.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_rule_based_systems/pics/reactive_rule_fire.png


--------------------------------------------------------------------------------
/other_notes/about_truth_values/README.md:
--------------------------------------------------------------------------------
 1 | # Truth Values
 2 | 
 3 | Once you think about it, you notice that Prolog is both cheating in pretending that it is working in two-valued logic and also deficient in modeling capabilities by keeping to two-valued logic. One day this may be extended! See also: [Paraconsistent Logic](https://plato.stanford.edu/entries/logic-paraconsistent/).
 4 | 
 5 | ![Truth Values](pics/extended_truth_values.svg)
 6 | 
 7 | Actually, the tabling implementation provides Well-Founded Semantics (with three truth values) for tables predicates.
 8 | 
 9 | - [Well-Founded Semantics](https://www.swi-prolog.org/pldoc/man?section=WFS)
10 | - [`tnot/1`](https://www.swi-prolog.org/pldoc/man?predicate=tnot/1)
11 | 
12 | 
13 | 


--------------------------------------------------------------------------------
/other_notes/about_truth_values/pics/extended_truth_values.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/about_truth_values/pics/extended_truth_values.png


--------------------------------------------------------------------------------
/other_notes/about_vocabulary/README.md:
--------------------------------------------------------------------------------
 1 | # Vocabulary
 2 | 
 3 | Some lingo one may encounter. Filled in as I go.
 4 | 
 5 | **Program**
 6 | 
 7 | David Warren says:
 8 | 
 9 | - "A program is a set of sentences in a given logic" 
10 | - Answers are logical consequences of the program as a set of statements in the logic
11 | - And logical consequence is defined in terms of a logical semantics, usaully a theory of model.
12 | 
13 | **Definite program** 
14 | 
15 | Program with Horn Clauses without negation, including without negation-as-failure.
16 | 
17 | **General (logic) programs**
18 | 
19 | Program with Horn Clauses that also has negative literals in the body. These are generally interpreted as "strongly negated atoms", not only "negation-as-failure atoms"
20 | 
21 | **Stratified programs**
22 | 
23 | Not sure.
24 | 
25 | **Names of list parts**
26 | 
27 | - Suffix
28 | - Prefix
29 | - Head
30 | - Tail
31 | - Tip
32 | - Fin
33 | - Backbone
34 | - Open list
35 | - Closed (or proper= list
36 | 
37 | **Elements of a clause**
38 | 
39 | - atom: in the logical formula sense, a single predicate call in a clause: `p(x,y,z)`, atomic formula
40 | - literal: in the logical formula sense, a positive or negative (negated) atom: `p(x,y,z)` or `¬p(x,y,z)` (sometimes `~p(x,y,z)` for "naf") 
41 | 
42 | **Elements of a query**
43 | 
44 | - atomic goal
45 | 
46 | **Clause**
47 | 
48 | **Horn clause*
49 | 
50 | **Definite clause**
51 | 
52 | **Guarded clause**
53 | 
54 | **Answer set**
55 | 
56 | **Propositional logic**
57 | 
58 | **First Order Logic**
59 | 
60 | **Reification**
61 | 
62 | **Higher Order Logic**
63 | 
64 | **Higher Order Programming**
65 | 
66 | **Proof theory**
67 | 
68 | **Model theory**
69 | 
70 | **Formula**
71 | 
72 | **Proposition**
73 | 
74 | **Statement**
75 | 
76 | **Sentence**
77 | 
78 | **Expression**
79 | 
80 | **Theorem**
81 | 
82 | **Tautology**
83 | 
84 | **Herbrand base**
85 | 
86 | **Herbrand universe**
87 | 
88 | 


--------------------------------------------------------------------------------
/other_notes/about_well_founded_semantics/README.md:
--------------------------------------------------------------------------------
 1 | # Well-founded semantics
 2 | 
 3 | Well-Founded Semantics are briefly discussed under "Tabling in the SWI-Prolog manual: [Well Founded Semantics](https://eu.swi-prolog.org/pldoc/man?section=WFS)
 4 | 
 5 | This is a three-valued logic (that's all I kno so far), with 
 6 | 
 7 | - true
 8 | - false
 9 | - undefined
10 | 
11 | See:
12 | 
13 | _Well-Founded and Stationary Models of Logic Programs_ (1994)
14 | 
15 | - Teodor Przymusinski
16 | - https://link.springer.com/article/10.1007/BF01530784
17 | - https://www.researchgate.net/publication/2299243_Well-Founded_and_Stationary_Models_of_Logic_Programs
18 | - Appears in: Annals of Mathematics and Artificial Intelligence, 1994, vol. 12, page 141-187
19 | 
20 | 
21 | 
22 | 
23 | 


--------------------------------------------------------------------------------
/other_notes/quick_map_of_lp_landscape/README.md:
--------------------------------------------------------------------------------
 1 | # Quick map of the logic programming landscape
 2 | 
 3 | Evidently incomplete and that diagram is already too detailed.
 4 | 
 5 | - [graphml format](quick_map_of_lp_landscape.graphml)
 6 |    - [SVG format](quick_map_of_lp_landscape.svg)
 7 |    - [PNG format](quick_map_of_lp_landscape.png)
 8 | 
 9 | ![Quick map of the Logic Programming landscape](quick_map_of_lp_landscape.svg)
10 | 
11 | 


--------------------------------------------------------------------------------
/other_notes/quick_map_of_lp_landscape/quick_map_of_lp_landscape.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/other_notes/quick_map_of_lp_landscape/quick_map_of_lp_landscape.png


--------------------------------------------------------------------------------
/pics/cosine_taylor_series/taylor_series.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/cosine_taylor_series/taylor_series.png


--------------------------------------------------------------------------------
/pics/program trees/clauses.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/program trees/clauses.png


--------------------------------------------------------------------------------
/pics/prolog_clause_explainer/Prolog Calling AND Tree.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/prolog_clause_explainer/Prolog Calling AND Tree.png


--------------------------------------------------------------------------------
/pics/prolog_clause_explainer/Prolog Calling.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/prolog_clause_explainer/Prolog Calling.png


--------------------------------------------------------------------------------
/pics/prolog_clause_explainer/Prolog Clause Logical Reading.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/prolog_clause_explainer/Prolog Clause Logical Reading.png


--------------------------------------------------------------------------------
/pics/prolog_clause_explainer/Prolog Clause Network.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/prolog_clause_explainer/Prolog Clause Network.png


--------------------------------------------------------------------------------
/pics/prolog_clause_explainer/Prolog Clause.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/prolog_clause_explainer/Prolog Clause.png


--------------------------------------------------------------------------------
/pics/prolog_clause_explainer/Prolog Infoflow.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/prolog_clause_explainer/Prolog Infoflow.png


--------------------------------------------------------------------------------
/pics/prolog_clause_explainer/Prolog Tree of Stuff.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/prolog_clause_explainer/Prolog Tree of Stuff.png


--------------------------------------------------------------------------------
/pics/variables_and_their_bindings/Variables and their bindings.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/variables_and_their_bindings/Variables and their bindings.png


--------------------------------------------------------------------------------
/pics/various/Hiroshige_Shinagawa_Station.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/various/Hiroshige_Shinagawa_Station.jpg


--------------------------------------------------------------------------------
/pics/various/Powerful_Prolog_and_AI_Bookshelf.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/various/Powerful_Prolog_and_AI_Bookshelf.jpg


--------------------------------------------------------------------------------
/pics/various/Taxonomy of programming Paradigms (by Peter van Roy).png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/pics/various/Taxonomy of programming Paradigms (by Peter van Roy).png


--------------------------------------------------------------------------------
/prolog_comparison_predicates/prolog_comparison_predicates.ods:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/prolog_comparison_predicates/prolog_comparison_predicates.ods


--------------------------------------------------------------------------------
/prolog_comparison_predicates/prolog_comparison_predicates.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/prolog_comparison_predicates/prolog_comparison_predicates.pdf


--------------------------------------------------------------------------------
/prolog_comparison_predicates/prolog_comparison_predicates.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/prolog_comparison_predicates/prolog_comparison_predicates.png


--------------------------------------------------------------------------------
/prolog_exercises/ab_dcg/ab_dcg.pl:
--------------------------------------------------------------------------------
 1 | :- module(ab_dcg,
 2 |    [
 3 |     phrase_acceptable/2
 4 |    ,acceptable//1
 5 |    ]).
 6 | 
 7 | :- use_module(library(clpfd)).
 8 | 
 9 | acceptable(0) --> [].
10 | acceptable(N1) -->  `ab`, { N #= N1-1, N #>= 0 }, acceptable(N).
11 | 
12 | phrase_acceptable(Text,N) :-
13 |    nonvar(Text),!,                   % guard to select "recognize" case
14 |    atom_codes(Text,Codes),           % text-to-recognize can be string or atom or numbner
15 |    phrase(acceptable(N),Codes,[]).
16 |    
17 | phrase_acceptable(Text,N) :- 
18 |    var(Text),!,                      % guard to select "generate" case
19 |    phrase(acceptable(N),Codes,[]),
20 |    atom_codes(Text,Codes).           % generated text is atom
21 |       
22 | 


--------------------------------------------------------------------------------
/prolog_exercises/ab_dcg/test_ab_dcg.pl:
--------------------------------------------------------------------------------
 1 | :- use_module(['ab_dcg.pl']).
 2 | 
 3 | % load with ?- [test_ab_dcg].
 4 | % run with  ?- run_tests.
 5 | 
 6 | :- begin_tests(ab_dcg).
 7 | 
 8 | test(generate,true(Bag == ['abababababab']))  :- 
 9 |    bagof(T,phrase_acceptable(T,6),Bag).
10 |    
11 | test(recognize,true(Bag == [3])) :- 
12 |    bagof(N,phrase_acceptable("ababab",N),Bag).
13 |    
14 | test(enumerate5,true(Bag == [['',0],['ab',1],['abab',2],['ababab',3],['abababab',4]])) :- 
15 |    bagof([T,N],limit(5,phrase_acceptable(T,N)),Bag). 
16 |    
17 | :- end_tests(ab_dcg).
18 | 
19 | 


--------------------------------------------------------------------------------
/prolog_exercises/between_sym.pl:
--------------------------------------------------------------------------------
 1 | % ==
 2 | % https://eu.swi-prolog.org/pldoc/doc_for?object=between/3
 3 | % 
 4 | % A naive symmetric between, which can generate increasing (step 1) and 
 5 | % decreasing (step -1) sequences. The "empty sequence", whereby between/3 
 6 | % fails at once, no longer exists.
 7 | % 
 8 | % In the case of a decreasing sequence, this is done by generating the whole
 9 | % sequence and storing it. Catastrophic on large sequences! The correct way
10 | % to implement this is via lazy ("generate-on-demand") sequences - just keep
11 | % a small state in an object and compute the next sequence member only when
12 | % requested. In Prolog, the "object" is the stack frame and "when requested"
13 | % is the backtracking "redo". See between/4 further below!
14 | % ==
15 | 
16 | between_sym(A,B,X) :-
17 | 
18 |    % No need to check parameters; let between/3 do that
19 |    % - between/3 throws if A,B not integers
20 | 
21 |    (A =< B)
22 |    ->    
23 |    between(A,B,X)
24 |    ;
25 |    (bagof(Q,between(B,A,Q),Seq),reverse(Seq,SeqR),member(X,SeqR)).
26 |    
27 | :- begin_tests(between_sym).
28 | 
29 | test(1, all(X = [1,2,3]))   :- between_sym(1,3,X).
30 | test(2, all(X = [3,2,1]))   :- between_sym(3,1,X).
31 | test(1, all(X = [-1,0,+1])) :- between_sym(-1,+1,X).
32 | test(2, all(X = [+1,0,-1])) :- between_sym(+1,-1,X).
33 | test(1, all(X = [0]))       :- between_sym(0,0,X).
34 | test(1, throws(_))          :- between_sym(a,0,_).
35 | 
36 | :- end_tests(between_sym).
37 | 
38 | rt(between_sym) :- run_tests(between_sym).
39 | 


--------------------------------------------------------------------------------
/prolog_exercises/digits_dcg/digits_dcg.pl:
--------------------------------------------------------------------------------
 1 | :- module(digits_dcg,
 2 |    [
 3 |    nonempty_atom_of_digits//1
 4 |    ]).
 5 | 
 6 | % ---
 7 | % Grab the longest nonempty sequence of digits.
 8 | % See also: https://eu.swi-prolog.org/pldoc/man?section=basics
 9 | %
10 | % Sadly, the code for reading codes from a list and getting an atom
11 | % and the code for checking an atom is not the same! 
12 | %
13 | % There is no inherent reason why this should be so, except that 
14 | % atom_codes/2 does not establihs a "constraint" among variables but 
15 | % is basically two functions pressed into one predicate.
16 | % ---
17 | 
18 | % If D is instantiated to an atom, 
19 | % break it into character codes and check that they are digits.
20 | 
21 | nonempty_atom_of_digits(D) --> 
22 |    { atom(D),! }, % guard
23 |    { atom_codes(D,Ns) }, 
24 |    nonempty_digits(Ns).
25 | 
26 | % If D is uninstantiated, 
27 | % grab character codes representing digits from the (implicit) input list
28 | % and merge them into an atom when done.
29 | 
30 | nonempty_atom_of_digits(D) --> 
31 |    { var(D),! },  % guard   
32 |    nonempty_digits(Ns),
33 |    { atom_codes(D,Ns) }.
34 | 
35 | % ---
36 | % Grabbing the digits from the implicit list (working as input)
37 | % Putting the digits into the implicit list (working as output) 
38 | % ---
39 | 
40 | % The "greedy processing" of "digits + more" comes first
41 | 
42 | nonempty_digits([N|Ns]) --> 
43 |    single_digit(N), 
44 |    nonempty_digits(Ns), 
45 |    !. % cut to avoid backtracking to shorter strings
46 | 
47 | % The single digit comes last
48 | 
49 | nonempty_digits([N]) -->
50 |    single_digit(N).
51 | 
52 | % Does the compiler make sure `0123456789` is just broken up once?
53 | % I don't know!
54 | 
55 | single_digit(N) --> 
56 |    [N], { memberchk(N,`0123456789`) }.
57 | 
58 | 
59 | 


--------------------------------------------------------------------------------
/prolog_exercises/digits_dcg/test_digits_dcg.pl:
--------------------------------------------------------------------------------
 1 | :- use_module('digits_dcg.pl').
 2 | 
 3 | % load with ?- [test_digits_dcg].
 4 | % run with  ?- run_tests.
 5 | 
 6 | recognize(InAtom,DigitsAtom,RestAtom,DcgGoal) :- 
 7 |    assertion(atom(InAtom)),
 8 |    atom_codes(InAtom,InCodes),
 9 |    % dynamic construction of phrase-able goal
10 |    compound_name_arguments(FullGoal,DcgGoal,[DigitsAtomVar]),
11 |    phrase(FullGoal,InCodes,RestCodes),
12 |    atom_codes(RestAtom,RestCodes),
13 |    % unfiy to return value in DigitsAtom or to compare with value in DigitsAtom
14 |    DigitsAtom = DigitsAtomVar.
15 | 
16 | % ---------
17 | 
18 | :- begin_tests(digits).
19 | 
20 | test("digits 12345",true([Digits,Rest] == ['12345',''])) :-
21 |    recognize('12345',Digits,Rest,nonempty_atom_of_digits).
22 | 
23 | test("digits 0",true([Digits,Rest] == ['0',''])) :-
24 |    recognize('0',Digits,Rest,nonempty_atom_of_digits).
25 | 
26 | test("no digits",fail) :-
27 |    recognize('',_Digits,_Rest,nonempty_atom_of_digits).
28 | 
29 | test("not digits",fail) :-
30 |    recognize('foo',_Digits,_Rest,nonempty_atom_of_digits).
31 | 
32 | test("digits with rest",true([Digits,Rest] == ['0123','foo'])) :-
33 |    recognize('0123foo',Digits,Rest,nonempty_atom_of_digits).
34 | 
35 | :- end_tests(digits).
36 | 
37 | 
38 | 


--------------------------------------------------------------------------------
/prolog_exercises/freeze_example.pl:
--------------------------------------------------------------------------------
 1 | bb :-
 2 |    debug(ccr),
 3 |    Ws=[W0,W1,W2,W3],
 4 |    debug(ccr,"freezing bucket_brigade(alpha)",[]),
 5 |    freeze(W0,bucket_brigade(alpha,V0,V1,Ws)),
 6 |    debug(ccr,"freezing bucket_brigade(bravo)",[]),
 7 |    freeze(W1,bucket_brigade(bravo,V1,V2,Ws)),
 8 |    debug(ccr,"freezing bucket_brigade(charlie)",[]),
 9 |    freeze(W2,bucket_brigade(charlie,V2,V3,Ws)),
10 |    debug(ccr,"freezing bucket_brigade(delta)",[]),
11 |    freeze(W3,bucket_brigade(delta,V3,VV,Ws)),
12 |    % wire up the bucket brigade
13 |    W0=V0,W1=V1,W2=V2,W3=V3,
14 |    what_is_frozen(bb,Ws),
15 |    debug(ccr,"wait for it...",[]),
16 |    sleep(1),
17 |    debug(ccr,"thawing bucket_brigade(alpha)",[]),
18 |    W0=[],
19 |    debug(ccr,"bucket arrived: ~q",[VV]).
20 | 
21 | what_is_frozen(_,[]) :- !.
22 | what_is_frozen(N,[W|Ws]) :-
23 |    frozen(W,G),
24 |    (G==true
25 |     -> debug(ccr,"~q : Nothing is frozen on: ~q",[N,W])
26 |     ;  debug(ccr,"~q : Goal ~q is frozen on: ~q",[N,G,W])),
27 |    what_is_frozen(N,Ws).
28 | 
29 | 
30 | bucket_brigade(N,Vin,Vout,Ws) :-
31 |    debug(ccr,"bucket_brigade ~q: Woke up with V = ~q!",[N,Vin]),
32 |    what_is_frozen(N,Ws),
33 |    Vout=[N|Vin].
34 | 
35 | 


--------------------------------------------------------------------------------
/prolog_exercises/grailsearch/grailsearch.pl:
--------------------------------------------------------------------------------
 1 | % ===
 2 | % A simple exercise in backtracking
 3 | % ===
 4 | 
 5 | % ===
 6 | % Acquiring the Holy Grail is our only hope
 7 | % ===
 8 | 
 9 | acquire_grail :- 
10 |    knights(Knights),
11 |    member(Knight,Knights),
12 |    %
13 |    % Printing a death announcement prior to getting the next knight
14 |    % online is a bit hard due to backtracking! How do I do that simply?
15 |    %
16 |    format("~q rides forth!\n",[Knight]),
17 |    search_for_the_grail(Knight,[],Map),
18 |    !, % Victory Cut!
19 |    announce(found,Knight,Map).
20 |                         
21 | acquire_grail :- 
22 |    announce(its_all_over,_,_),fail.
23 | 
24 | % ===
25 | % The King's Messenger proclaims
26 | % ===
27 |    
28 | announce(found,Who,Map) :- 
29 |   format("The Holy Grail has been found by Brave Knight ~q!\n",[Who]),
30 |   format("Here is how to get there: ~q\n",[Map]).
31 |   
32 | announce(its_all_over,_,_) :- 
33 |   format("Camelot is finished!\n").
34 | 
35 | % ===
36 | % These Knights hang around the round table usually
37 | % ===
38 | 
39 | knights([gavain,lancelot,perceval]).
40 | 
41 | % ===
42 | % The Holy Grail is found after pressing forward 6 times
43 | % But at each move, the Knight has 1/3 chance of dying 
44 | % ===
45 | 
46 | search_for_the_grail(Knight,Acc,Acc) :-    
47 |    length(Acc,6),
48 |    !, % guard cut
49 |    format("~q: 'God be praised!'\n",[Knight]).
50 |    
51 | search_for_the_grail(Knight,Acc,Map) :- 
52 |    random(0.0,1.0,X), 
53 |    X < 0.666,             
54 |    !, % guard cut
55 |    format("~q: 'The search continues!'\n",[Knight]),
56 |    search_for_the_grail(Knight,[fwd|Acc],Map). 
57 |       
58 | search_for_the_grail(Knight,_,_) :- 
59 |   format("~q: 'Arrgh!'\n",[Knight]),
60 |   fail.
61 |   
62 | 


--------------------------------------------------------------------------------
/prolog_exercises/rosettacode/sort_disjoint_sublist/README.txt:
--------------------------------------------------------------------------------
1 | http://rosettacode.org/wiki/Sort_disjoint_sublist
2 | 


--------------------------------------------------------------------------------
/prolog_exercises/rosettacode/sort_disjoint_sublist/sds_sol_2.pl:
--------------------------------------------------------------------------------
 1 | sort_disjoint_sublist(Values,Indexes,ValuesSorted) :-
 2 |    sort(Indexes,IndexesSorted),
 3 |    insert_fresh_vars_by_splintering(IndexesSorted,Values,FreshVars,ValsToSort,ValuesFreshened),
 4 |    msort(ValsToSort,ValsSorted),  % this is the "sorting of values"
 5 |    % The next two lines could be left out with suitable naming, 
 6 |    % but they make explicit what happens:
 7 |    FreshVars = ValsSorted,         % fresh variables are unified with sorted variables
 8 |    ValuesSorted = ValuesFreshened. % ValuesFreshend is automatically the sought output 
 9 | 
10 | % ===
11 | % Using append/3 and nth0/3 from 
12 | % library(lists) at https://eu.swi-prolog.org/pldoc/man?section=lists
13 | % ===
14 | 
15 | insert_fresh_vars_by_splintering([I|Is],Values,[Fresh|FreshVars],[ValAtI|ValsToSort],ValsFreshyFinal) :-
16 |    splinter(Values,I,ValAtI,ValsFront,ValsBack),         % splinter  Values  --> ValsFront + ValAtI + ValsBack
17 |    append([ValsFront,[Fresh],ValsBack],ValsFreshyNext),  % recompose ValsFront + Fresh + ValsBack --> ValuesFreshyNext
18 |    insert_fresh_vars_by_splintering(Is,ValsFreshyNext,FreshVars,ValsToSort,ValsFreshyFinal).
19 | 
20 | insert_fresh_vars_by_splintering([],V,[],[],V).
21 | 
22 | % "splinter" a list into a frontlist, the element at position N and a backlist
23 |  
24 | splinter(List, N, Elem, Front, Back) :-
25 |     length(Front, N),
26 |     append(Front, [Elem|Back], List).
27 | 
28 | 


--------------------------------------------------------------------------------
/prolog_exercises/rosettacode/sort_disjoint_sublist/sds_unittests.pl:
--------------------------------------------------------------------------------
 1 | % ===
 2 | % Unit tests!
 3 | % We use the "R" intermediate var to decouple processing by the predicate 
 4 | % from subsequent checking against expected result.
 5 | %
 6 | % For unit testing code, see
 7 | % https://www.swi-prolog.org/pldoc/doc_for?object=section(%27packages/plunit.html%27)
 8 | % ===
 9 |  
10 | :- begin_tests(sort_disjoint_sublist).
11 | 
12 | test(rosetta)  :- sort_disjoint_sublist([7,6,5,4,3,2,1,0],[6,1,7],R), R = [7,0,5,4,3,2,1,6].
13 | test(another1) :- sort_disjoint_sublist([4,2,1,4,5,5,0,0],[3,4,5,6,7],R), R = [4,2,1,0,0,4,5,5].
14 | test(another2) :- sort_disjoint_sublist([4,2,1,4,5,5,0,0],[0,1,2,3,4],R), R = [1,2,4,4,5,5,0,0].
15 | test(another3) :- sort_disjoint_sublist([4,2,1,4,5,5,0,0],[0,2,4,6],R), R = [0,2,1,4,4,5,5,0].
16 | test(another4) :- sort_disjoint_sublist([4,2,1,4,5,5,0,0],[1,3,5,7],R), R = [4,0,1,2,5,4,0,5].
17 | test(edge1)    :- sort_disjoint_sublist([],[],R), R = [].
18 | test(edge2)    :- sort_disjoint_sublist([3,2,1],[],R), R = [3,2,1].
19 | test(edge3)    :- sort_disjoint_sublist([3,2,1],[0],R), R = [3,2,1].
20 | test(edge4)    :- sort_disjoint_sublist([3,2,1],[1],R), R = [3,2,1].
21 | test(edge5)    :- sort_disjoint_sublist([3,2,1],[2],R), R = [3,2,1].
22 | test(x1)       :- sort_disjoint_sublist([3,2,1],[0,1,2],R), R = [1,2,3].
23 | test(x2)       :- sort_disjoint_sublist([1,2,3],[0,1,2],R), R = [1,2,3].
24 | test(dups1)    :- sort_disjoint_sublist([3,2,1],[1,1,1],R), R = [3,2,1].
25 | test(dups2)    :- sort_disjoint_sublist([3,2,1],[2,1,2],R), R = [3,1,2].
26 | test(fail1,[fail]) :- sort_disjoint_sublist([1,2],[0,1,2],_).
27 | test(fail2,[fail]) :- sort_disjoint_sublist([],[0,1],_).
28 |  
29 | :- end_tests(sort_disjoint_sublist).
30 |  
31 | % ---
32 | % Run unit tests.
33 | % ---
34 |  
35 | rt :- run_tests(sort_disjoint_sublist).
36 | 
37 | 


--------------------------------------------------------------------------------
/prolog_exercises/stackoverflow/Breadth-First Traversal of a List of Lists.txt:
--------------------------------------------------------------------------------
 1 | Breadth-First traversal of list-of-lists by Will Ness:
 2 | 
 3 | https://stackoverflow.com/questions/64936541/splice-in-sublists-in-a-list-without-using-flatten-2/
 4 | 
 5 | In case you want to roll your own, here's breadth-first enumeration of arbitrarily nested lists:
 6 | 
 7 | bfs( XS, L) :- bfs( s(z), [XS|Q], Q,  L, []).
 8 | 
 9 | bfs( z, _, _, Z, Z).
10 | bfs( s(N), [[]   |P], Q,  L, Z) :- bfs( N, P, Q,  L, Z).
11 | bfs( s(N), [[A|B]|P], Q,  L, Z) :-
12 |   is_list(A) 
13 |   -> Q = [A|R], bfs( s(s(N)), [B|P], R,  L, Z)   % enqueue A, or
14 |   ;  L = [A|R], bfs(   s(N),  [B|P], Q,  R, Z).  % produce A
15 | 
16 | The first argument is the distance between read and write point on the queue. When they meet the queue has become exhausted and we stop. Both the input queue and the output list are maintained as difference list pairs of head and tail variables.
17 | 
18 | Trying it out:
19 | 
20 | 12 ?- bfs( [[[6]],1,2,[4,[[[[[7]]]]],5],3], A).
21 | A = [1, 2, 3, 4, 5, 6, 7] .
22 | 
23 | You will need to augment it to skip the non-lists in the top level.
24 | 


--------------------------------------------------------------------------------
/prolog_exercises/stackoverflow/corona_symptoms.pl:
--------------------------------------------------------------------------------
 1 | % ---
 2 | % Symptoms are listed naturally in a list.
 3 | % There are 11 symptoms
 4 | 
 5 | symptoms( [conjunctivitis,
 6 |            sore_throat,
 7 |            fatigue,
 8 |            shake,
 9 |            diarrhea,        
10 |            runny_nose,      
11 |            cold,
12 |            muscle_pain,
13 |            chest_pressure,
14 |            loss_of_taste,          
15 |            fever] ).
16 | 
17 | % ---
18 | % Go through the symptoms list, but don't use read/1
19 | % instead us read_line_to_string/2
20 | % https://eu.swi-prolog.org/pldoc/man?predicate=read_line_to_string/2
21 | 
22 | ask_about_symptoms([],[]).
23 | ask_about_symptoms([Symptom|MoreSymptoms],[Answer-Symptom|MorePairs]) :-
24 |    repeat,
25 |    format("Do you have: ~s?\n",[Symptom]),
26 |    read_line_to_string(user_input,S1),
27 |    string_lower(S1,S2),
28 |    (
29 |       member(S2,["yes","y","ja","oui"])
30 |       ->
31 |       Answer = yes
32 |       ;
33 |       member(S2,["no","n","nein","non"])
34 |       ->
35 |       Answer = no
36 |       ;
37 |       format("Please try again\n",[]),fail % Back to "repeat"
38 |    ),   
39 |    ask_about_symptoms(MoreSymptoms,MorePairs).
40 |     
41 | is_yes_pair(yes-_).
42 | 
43 | ask_candidate :-
44 |    symptoms(Symptoms),
45 |    ask_about_symptoms(Symptoms,AnswerPairs),
46 |    format("So you say you have the following symptoms: ~q~n",[AnswerPairs]),
47 |    !, % don't go back to asking
48 |    include(is_yes_pair,AnswerPairs,Included),
49 |    format("So you say you have the following symptoms: ~q~n",[Included]),
50 |    length(Included,Hits),
51 |    ((Hits>=3) -> format("Looks bad.~n",[]) ; format("You probably don't have it.~n",[])).
52 |    
53 | 
54 | 


--------------------------------------------------------------------------------
/prolog_exercises/stackoverflow/rgbnext.pl:
--------------------------------------------------------------------------------
 1 | % Predicate to generate lists of three color atoms.
 2 | % You pass it the "current" and it defines the "next" one.
 3 | % From https://stackoverflow.com/questions/61526198/getting-all-the-combinations-of-colors-in-a-list
 4 | 
 5 | :- use_module(library(clpfd)).
 6 | 
 7 | rgbnumber(red,0).
 8 | rgbnumber(blue,1).
 9 | rgbnumber(green,2).
10 | 
11 | rgbnumberlist([L0,L1,L2],N) :- 
12 |    rgbnumber(L0,N0), N0 in 0..2,
13 |    rgbnumber(L1,N1), N1 in 0..2,
14 |    rgbnumber(L2,N2), N2 in 0..2,
15 |    N #= N0+N1*3+N2*3*3.
16 | 
17 | rgbnext(Current,Next,Wrap) :- 
18 |    rgbnumberlist(Current,N),
19 |    succ(N,Nx),
20 |    Nxm is (Nx mod (3*3*3)), % Beware precedence: mod is as strong as *
21 |    (Nx > Nxm -> Wrap = true ; Wrap = false),
22 |    rgbnumberlist(Next,Nxm).
23 | 


--------------------------------------------------------------------------------
/prolog_exercises/stackoverflow/simple graph walker (finite automaton).pl:
--------------------------------------------------------------------------------
 1 | % https://stackoverflow.com/questions/64807478/implementing-an-automata-in-prolog
 2 | 
 3 | :- use_module(library(clpfd)).
 4 | 
 5 | accepts(Ts,L) :-                 % Accept the list of transitions Ts of length L if
 6 |    start(S),                     % ...starting from a start state S
 7 |    accepts_from(S,Ts,L).         % ...you can accept the Ts of length L.                       
 8 | 
 9 | accepts_from(S,[T|Ts],L) :-      % Accept the transitions [T|Ts] when at S if
10 |    (nonvar(L) 
11 |     -> L >= 1
12 |     ;  true),                    % L (if it is bound) is at least 1 (this can be replaced by L #> 0)
13 |    delta(S,T,SN),                % ...and there is a transition S->SN via T
14 |    Lm #= L-1,                    % ...and the new length is **constrained to be** 1 less than the previous length
15 |    accepts_from(SN,Ts,Lm).       % ...and you can accept the remaining Ts of length Lm from SN.
16 | 
17 | accepts_from(S,[],0) :-          % If there is no transition left, length L must be 0 and we accept if
18 |    end(S).                       % ...we are a final state.
19 | 
20 | delta(1,d,2).
21 | delta(2,a,2).
22 | delta(2,b,2).
23 | delta(2,d,4).
24 | delta(2,e,5).
25 | delta(2,c,3).
26 | delta(3,d,6).
27 | delta(6,c,5).
28 | start(1).
29 | end(4).
30 | end(5).
31 | 
32 | generate :- 
33 |    between(0,7,L),
34 |    findall(Ts,accepts(Ts,L),Bag),
35 |    length(Bag,BagLength),
36 |    format("Found ~d paths of length ~d through the graph\n",[BagLength,L]),
37 |    maplist({L}/[Ts]>>format("~d : ~q\n",[L,Ts]),Bag).
38 | 


--------------------------------------------------------------------------------
/prolog_exercises/test_plunit.pl:
--------------------------------------------------------------------------------
 1 | :- begin_tests(choicepoints).
 2 | 
 3 | test(one)                     :- multi_danger(1).                   % Will warn "Test succeeded with choicepoint"
 4 | test(two,[nondet])            :- multi_danger(1).                   % Will not warn, but only collects one
 5 | test(three,[all(X == [1,2])]) :- multi_success(X).                  % Collects them all, verifies on the left
 6 | test(four)                    :- once(multi_danger(1)).             % Only collects one
 7 | test(five)                    :- bagof(X,multi_success(X),[1,2]).   % Collects them all, verifies on the right
 8 | test(six,true(Bag == [1,2]))  :- bagof(X,multi_success(X),Bag).     % Collects them all, verifies on the left
 9 | test(seven,[fail])            :- multi_success(100).                % Fails at once
10 | test(eight,[throws(_)])       :- bagof(X,multi_danger(X),_Bag).     % Throws in second round
11 | test(nine,[fail])             :- bagof(X,multi_success(X),[_,_,_]). % Fails because it needs three results, but there are two
12 | test(ten,[fail])              :- bagof(X,multi_success(X),[E]).     % Fails because it wants one result, but there are two
13 | 
14 | multi_danger(X) :- X=1.
15 | multi_danger(_) :- throw("Ouch!").
16 | 
17 | multi_success(X) :- X=1.
18 | multi_success(X) :- X=2.
19 | 
20 | :- end_tests(choicepoints).
21 | 
22 | rt(_) :- run_tests(choicepoints).
23 | 


--------------------------------------------------------------------------------
/swipl_notes/about_attributed_variables/enforced_integer_list.pl:
--------------------------------------------------------------------------------
 1 | :- module(enforced_integer_list, [ list_of_int/2 ]).
 2 | 
 3 | :- debug(enforced_integer_list).
 4 | 
 5 | % ---
 6 | % Service predicate
 7 | % ---
 8 | % Create a list of variables that can only be unified with integers.
 9 | % This is a low-effort implementation, as it covers only one way of
10 | % how this could be called: creation of a new list of unbound variables.
11 | 
12 | list_of_int(Length,List) :-
13 |    must_be(nonneg,Length),
14 |    must_be(var,List),
15 |    length(List,Length),
16 |    maplist([X]>>put_attr(X,enforced_integer_list,make_sure_it_is_an_int),List).
17 | 
18 | % ---
19 | % The hook called on unification
20 | % ---
21 | 
22 | attr_unify_hook(make_sure_it_is_an_int,PUV) :-
23 |    integer(PUV) -> case_integer(PUV) ;
24 |    string(PUV)  -> case_string(PUV)  ;
25 |    var(PUV)     -> case_var(PUV)     ;
26 |    case_default.
27 | 
28 | % ---
29 | % Unification hook catch-all success
30 | % ---
31 | 
32 | attr_unify_hook(ATTV,_PUV) :-
33 |    ATTV \== make_sure_it_is_an_int,
34 |    debug(enforced_integer_list,"attr_unify_hook/2 called with unknown ATTV: ~q",[ATTV]).
35 | 
36 | % ---
37 | % Cases
38 | % ---
39 | 
40 | case_integer(PUV) :-
41 |    debug(enforced_integer_list,"Trying to unify with an integer: ~q. Unification okayed!",[PUV]).
42 | 
43 | case_string(PUV) :-
44 |    debug(enforced_integer_list,"Received string '~s'; this means throwing",[PUV]),
45 |    type_error(integer,PUV).
46 | 
47 | case_var(PUV) :-
48 |    debug(enforced_integer_list,"Trying to fuse two variables. Unification okayed!",[]),
49 |    assertion(get_attr(PUV,enforced_integer_list,make_sure_it_is_an_int)).
50 | 
51 | case_default :-
52 |    debug(enforced_integer_list,"Trying to unify with something that is neither an integer nor an unbound variable: Vetoed!",[]),
53 |    fail.
54 | 


--------------------------------------------------------------------------------
/swipl_notes/about_attributed_variables/list_test.pl:
--------------------------------------------------------------------------------
 1 | :- module(enforced_integer_list, [ list_of_int/2 ]).
 2 | 
 3 | :- debug(enforced_integer_list).
 4 | 
 5 | % ---
 6 | % Service predicate
 7 | % ---
 8 | % Create a list of variables that can only be unified with integers.
 9 | % This is a low-effort implementation, as it covers only one way of 
10 | % how this could be called: creation of a new list of unbound variables.
11 | 
12 | list_of_int(Length,List) :-
13 |    must_be(nonneg,Length),
14 |    must_be(var,List),
15 |    length(List,Length),
16 |    maplist([X]>>put_attr(X,enforced_integer_list,make_sure_it_is_an_int),List).
17 | 
18 | % ---
19 | % The hook called on unification
20 | % ---
21 | 
22 | attr_unify_hook(make_sure_it_is_an_int,PUV) :-
23 |    integer(PUV) -> case_integer(PUV) ;
24 |    string(PUV)  -> case_string(PUV)  ;
25 |    var(PUV)     -> case_var(PUV)     ;
26 |    case_default.
27 | 
28 | % ---
29 | % Unification hook catch-all success
30 | % ---
31 | 
32 | attr_unify_hook(ATTV,_PUV) :-
33 |    ATTV \== make_sure_it_is_an_int,
34 |    debug(enforced_integer_list,"attr_unify_hook/2 called with unknown ATTV: ~q",[ATTV]).
35 | 
36 | % ---
37 | % Cases
38 | % ---
39 | 
40 | case_integer(PUV) :-
41 |    debug(enforced_integer_list,"Trying to unify with an integer: ~q. Unification okayed!",[PUV]).
42 | 
43 | case_string(PUV) :-
44 |    debug(enforced_integer_list,"Received string '~s'; this means throwing",[PUV]),
45 |    type_error(integer,PUV).
46 | 
47 | case_var(PUV) :-
48 |    debug(enforced_integer_list,"Trying to fuse two variables. Unification okayed!",[]), 
49 |    assertion(get_attr(PUV,enforced_integer_list,make_sure_it_is_an_int)).
50 | 
51 | case_default :-
52 |    debug(enforced_integer_list,"Trying to unify with something that is neither an integer nor an unbound variable: Vetoed!",[]),
53 |    fail.
54 | 
55 |  
56 | 


--------------------------------------------------------------------------------
/swipl_notes/about_attributed_variables/merging_attributed_variables/merging_attributed_variables.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_attributed_variables/merging_attributed_variables/merging_attributed_variables.png


--------------------------------------------------------------------------------
/swipl_notes/about_attributed_variables/when_is_the_hook_triggered/when_is_the_hook_triggered.ods:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_attributed_variables/when_is_the_hook_triggered/when_is_the_hook_triggered.ods


--------------------------------------------------------------------------------
/swipl_notes/about_attributed_variables/when_is_the_hook_triggered/when_is_the_hook_triggered.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_attributed_variables/when_is_the_hook_triggered/when_is_the_hook_triggered.pdf


--------------------------------------------------------------------------------
/swipl_notes/about_attributed_variables/when_is_the_hook_triggered/when_is_the_hook_triggered.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_attributed_variables/when_is_the_hook_triggered/when_is_the_hook_triggered.png


--------------------------------------------------------------------------------
/swipl_notes/about_chr/Logical Interpretation of CHR.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_chr/Logical Interpretation of CHR.png


--------------------------------------------------------------------------------
/swipl_notes/about_concept_of_variable/concept_of_variable.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_concept_of_variable/concept_of_variable.png


--------------------------------------------------------------------------------
/swipl_notes/about_concept_of_variable/unification_example.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_concept_of_variable/unification_example.png


--------------------------------------------------------------------------------
/swipl_notes/about_conditions/code/continuation_based_condition.pl:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | 
 4 | 
 5 | % ===
 6 | % Run it
 7 | % ===
 8 | 
 9 | run(one) :- with_advice().
10 | 
11 | 
12 | 
13 | 
14 | 
15 |       
16 | 


--------------------------------------------------------------------------------
/swipl_notes/about_continuations/archive/faulty_code/Faulty prolog program structure.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_continuations/archive/faulty_code/Faulty prolog program structure.png


--------------------------------------------------------------------------------
/swipl_notes/about_continuations/archive/faulty_code/explodes3.pl:
--------------------------------------------------------------------------------
 1 | # As used in
 2 | # https://github.com/SWI-Prolog/swipl-devel/issues/706
 3 | # to demonstrate a segmentation fault problem.
 4 | #
 5 | # However, this program in itself is faulty!
 6 | 
 7 | loop_until(N) :-
 8 |    nb_setval(count,0),
 9 |    reset(capture_deposit_cmd(N),obtain(Count),Continuation),
10 |    (
11 |       (Continuation == 0) 
12 |       ->
13 |       true
14 |       ;
15 |       (assertion(var(Count)),
16 |        nb_getval(count,Count),
17 |        call(Continuation))
18 |    ).
19 | 
20 | capture_deposit_cmd(N) :-
21 |    reset(capture_reset_cmd(N),deposit(Count),Continuation),
22 |    (
23 |       (Continuation == 0) 
24 |       ->
25 |       true
26 |       ;
27 |       (assertion(nonvar(Count)),
28 |        nb_setval(count,Count),
29 |        call(Continuation))
30 |    ).
31 | 
32 | infinitizer(Goal) :-
33 |    call(Goal),
34 |    infinitizer(Goal).
35 |    
36 | capture_reset_cmd(N) :-
37 |    reset(
38 |       infinitizer(in_loop_action(N)),
39 |       escape_from_loop(FinalN),
40 |       _),
41 |    format("The final count is (unsurprisingly) equal to ~d: ~d\n",[N,FinalN]).
42 | 
43 |    
44 | in_loop_action(N) :-
45 |    shift(obtain(Count)),
46 |    (
47 |       (N == Count) 
48 |       -> 
49 |       shift(escape_from_loop(Count))
50 |       ;
51 |       (format("The count is ~d\n",[Count]),
52 |        NewCount is Count+1,
53 |        shift(deposit(NewCount)))
54 |    ).
55 | 
56 | 


--------------------------------------------------------------------------------
/swipl_notes/about_continuations/code/effect_handler/run_counter.pl:
--------------------------------------------------------------------------------
 1 | % =============================================================================
 2 | % Implement a simple counter using the "effect handler" infrastructure.
 3 | % =============================================================================
 4 | % Run with ?- run_counter.
 5 | 
 6 | :- use_module('effect_handler.pl').
 7 | 
 8 | :- debug(count).
 9 | 
10 | % ===
11 | % The counting "client code". The state S is of the form [String,Integer] where
12 | % the Integer is a counting variable that counts down to 0 and the String
13 | % accumulates the values that the counting variable took on.
14 | % ===
15 | 
16 | count :-
17 |    get_state([Text,Counter]),
18 |    debug(count,"Client: Got state ~q",[[Text,Counter]]),
19 |    maybe_loop(Text,Counter).
20 | 
21 | maybe_loop(Text,Counter) :-
22 |    Counter >= 0,
23 |    !,
24 |    NewCounter is Counter-1,
25 |    string_extend(Text,Counter,NewText),
26 |    debug(count,"Client: Putting state ~q",[[NewText,NewCounter]]),
27 |    put_state([NewText,NewCounter]),
28 |    count.  % loop around, without any local arguments!
29 | 
30 | maybe_loop(_,_).  % stop the loop, we are done!
31 | 
32 | % ---
33 | % Helper
34 | % ---
35 | 
36 | string_extend("",Counter,NewText) :-
37 |    !,string_concat("",Counter,NewText).
38 | 
39 | string_extend(Text,Counter,NewText) :-
40 |    string_concat(Text,"+",Text2),
41 |    string_concat(Text2,Counter,NewText).
42 | 
43 | % ===
44 | % Call the following at the toplevel.
45 | % ===
46 | % Notice the "Inversion of Control" pattern: The "client code" count/0
47 | % implements the actual counting and is managed/called by the generic effect
48 | % handler predicate with_state/3.
49 | 
50 | run_counter :-
51 |    with_state(count,["",4],Out),
52 |    debug(count,"Final state is ~q",[Out]).
53 | 
54 | 


--------------------------------------------------------------------------------
/swipl_notes/about_continuations/code/exercise/looping.pl:
--------------------------------------------------------------------------------
 1 | % In an unexiting development, we can build a loop that calls `reset/3` to activate a 
 2 | % loop-worker-predicate on each loop passage instead of just *calling* the predicate.
 3 | % directly. To make things more interesting, we can store the continuations of 
 4 | % loop-worker-predicate obtained from `reset/3` and call them for finalization at the end.
 5 |      
 6 | :- debug(loop).
 7 | 
 8 | loop(N) :-
 9 |    loop_2(N,[],WConts),
10 |    maplist(
11 |       [WCont]>>(reset(WCont,_,C),assertion(C==0)), % use a library(yall) lambda
12 |       WConts).
13 | 
14 | loop_2(0,WConts,WConts) :- 
15 |    !,
16 |    debug(loop,"Loop is done",[]).
17 | 
18 | loop_2(N,WContsDown,[WCont|WContsUp]) :-   % accumulate worker continuations in-order
19 |    assertion(N>0),
20 |    debug(loop,"Switching to loop_worker(~d)",[N]),
21 |    reset(loop_worker(N),mine,WCont),
22 |    debug(loop,"Back in loop",[]),
23 |    Nm is N-1,
24 |    loop_2(Nm,WContsDown,WContsUp).         % tail-recursive call
25 |        
26 | loop_worker(N) :-
27 |   debug(loop,"In loop_worker(~d)",[N]),
28 |   shift(mine),
29 |   debug(loop,"Finalizing loop_worker(~d)",[N]).
30 | 
31 | /*
32 | And so:
33 | 
34 | ?- loop(4).
35 | % Switching to loop_worker(4)
36 | % In loop_worker(4)
37 | % Back in loop
38 | % Switching to loop_worker(3)
39 | % In loop_worker(3)
40 | % Back in loop
41 | % Switching to loop_worker(2)
42 | % In loop_worker(2)
43 | % Back in loop
44 | % Switching to loop_worker(1)
45 | % In loop_worker(1)
46 | % Back in loop
47 | % Loop is done
48 | % Finalizing loop_worker(4)
49 | % Finalizing loop_worker(3)
50 | % Finalizing loop_worker(2)
51 | % Finalizing loop_worker(1)
52 | true.
53 | */
54 | 


--------------------------------------------------------------------------------
/swipl_notes/about_continuations/code/iterator/pics/iterator_and_master_coroutine.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_continuations/code/iterator/pics/iterator_and_master_coroutine.png


--------------------------------------------------------------------------------
/swipl_notes/about_continuations/code/trial/reset_and_reset.pl:
--------------------------------------------------------------------------------
 1 | % ===
 2 | % Trying weird reset sequence. Experimental.
 3 | % ===
 4 | 
 5 | handler_1(Goal,Count) :-
 6 |    ((Count == 0) 
 7 |     -> reset(handler_2(_,0),postbox_1(X),Cont)
 8 |     ;  reset(Goal,postbox_1(X),Cont)),
 9 |    format("handler_1 at count = ~q received ~q\n",[Count,X]),
10 |    ((Cont == 0) 
11 |     -> true 
12 |     ; (
13 |        compound_name_arity(Cont,Name,Arity),
14 |        format("The continuation has name '~q' and ~d arguments\n",[Name,Arity]),
15 |        succ(Count,NewCount),
16 |        handler_1(Cont,NewCount))).
17 | 
18 | handler_2(Goal,Count) :-
19 |    ((Count == 0) 
20 |     -> reset(handler_3(_,0),postbox_2(X),Cont)
21 |     ;  reset(Goal,postbox_2(X),Cont)),
22 |    format("handler_2 at count = ~q received ~q\n",[Count,X]),
23 |    ((Cont == 0) 
24 |     -> true 
25 |     ; (succ(Count,NewCount),handler_2(Cont,NewCount))).
26 | 
27 | handler_3(Goal,Count) :-
28 |    ((Count == 0) 
29 |     -> reset(worker(10),postbox_3(X),Cont)
30 |     ;  reset(Goal,postbox_3(X),Cont)),
31 |    format("handler_3 at count = ~q received ~q\n",[Count,X]),
32 |    ((Cont == 0) 
33 |     -> true 
34 |     ; (succ(Count,NewCount),handler_3(Cont,NewCount))).
35 | 
36 | worker(Count) :-
37 |    (Count < 0) 
38 |    -> true
39 |    ;  (random(X),
40 |        random_member(P,[postbox_1(X),postbox_2(X),postbox_3(X)]), 
41 |        format("worker at count ~q will shift ~q\n",[Count,P]),
42 |        shift(P),
43 |        format("worker back from shift\n"),
44 |        NewCount is Count-1,
45 |        worker(NewCount)).
46 | 
47 | run :-
48 |    handler_1(_,0).
49 |  
50 | 
51 | 
52 | 


--------------------------------------------------------------------------------
/swipl_notes/about_continuations/pics/back_and_forth.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_continuations/pics/back_and_forth.png


--------------------------------------------------------------------------------
/swipl_notes/about_continuations/pics/limited_application.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_continuations/pics/limited_application.png


--------------------------------------------------------------------------------
/swipl_notes/about_continuations/pics/reset_points_as_resources.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_continuations/pics/reset_points_as_resources.png


--------------------------------------------------------------------------------
/swipl_notes/about_continuations/pics/reset_points_as_resources_call_stack.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_continuations/pics/reset_points_as_resources_call_stack.png


--------------------------------------------------------------------------------
/swipl_notes/about_continuations/pics/successfully_switching_between_2_branches_on_the_stack.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_continuations/pics/successfully_switching_between_2_branches_on_the_stack.png


--------------------------------------------------------------------------------
/swipl_notes/about_dcgs/example_abba/regex_fsm_2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_dcgs/example_abba/regex_fsm_2.png


--------------------------------------------------------------------------------
/swipl_notes/about_dcgs/example_dcg_for_abstar.pl:
--------------------------------------------------------------------------------
 1 | % ===
 2 | % Generate or recognize (ab)*
 3 | % ===
 4 | 
 5 | :- use_module(library(clpfd)).
 6 | 
 7 | acceptable(0) --> [].
 8 | acceptable(N1) -->  `ab`, { N #= N1-1, N #>= 0 }, acceptable(N).
 9 | 
10 | phrase_acceptable(Text,N) :-
11 |    nonvar(Text),!,                   % guard to select "recognize" case
12 |    atom_codes(Text,Codes),           % text-to-recognize can be string or atom or numbner
13 |    phrase(acceptable(N),Codes,[]).
14 |    
15 | phrase_acceptable(Text,N) :- 
16 |    var(Text),!,                      % guard to select "generate" case
17 |    phrase(acceptable(N),Codes,[]),
18 |    atom_codes(Text,Codes).           % generated text is atom
19 |       
20 | :- begin_tests(dcg).
21 | 
22 | test(generate,[true(Truly)])  :- 
23 |    bagof(T,phrase_acceptable(T,6),Bag),
24 |    Truly = (Bag == ['abababababab']).
25 |    
26 | test(recognize,[true(Truly)]) :- 
27 |    bagof(N,phrase_acceptable("ababab",N),Bag),
28 |    Truly = (Bag == [3]).
29 |    
30 | test(enumerate5,[true(Truly)]) :- 
31 |    bagof([T,N],limit(5,phrase_acceptable(T,N)),Bag), 
32 |    Truly = (Bag == [['',0],['ab',1],['abab',2],['ababab',3],['abababab',4]]).
33 |    
34 | :- end_tests(dcg).
35 | 
36 | rt(dcg) :- run_tests(dcg).
37 | 


--------------------------------------------------------------------------------
/swipl_notes/about_dcgs/read_file.pl:
--------------------------------------------------------------------------------
 1 | :- debug(parsing).
 2 | 
 3 | file(Ts) --> text_blocks(Ts).
 4 | 
 5 | text_blocks(Ts) --> noncomment_block(Ts), comment_block(Ts), text_blocks(Ts).
 6 | text_blocks(Ts) --> comment_block(Ts), text_blocks(Ts).
 7 | 
 8 | comment_blocks --> comment_block.
 9 | comment_blocks --> comment_block, comment_blocks.
10 | 
11 | comment_block(Cs) --> `/*`, text_with_comment_blocks(Cs), `*/`.
12 | 
13 | 
14 | 
15 | commented_text([]), `*/` --> `*/`,!.
16 | commented_text([]), `/*` --> `/*`,!.
17 | commented_text([C|Cs])   --> [C],!,commented_text(Cs).
18 | commented_text([])       --> [].
19 | 
20 | 
21 | 
22 | 
23 | file --> block_comment_free_text(T).
24 | file --> block_comment_free_text(T), block_comment, 
25 | 
26 | file --> arbitrary(P), `/*`, comment_content, `*/`, arbitrary(P).
27 | 
28 | /*
29 | 
30 | /*
31 | 
32 | main('*').
33 | 
34 | */
35 | 
36 | file  --> lines.
37 | 
38 | lines --> line(PxCs,SxCs), `\n\r`,!, { printline(PxCs,SxCs) }, lines.
39 | lines --> line(PxCs,SxCs), `\n`  ,!, { printline(PxCs,SxCs) }, lines.
40 | lines --> line(PxCs,SxCs), `\r`  ,!, { printline(PxCs,SxCs) }, lines.
41 | lines --> line(PxCs,SxCs),           { printline(PxCs,SxCs) }.
42 | 
43 | 
44 | printline(PxCs,SxCs) :-
45 |    atom_codes(Px,PxCs), 
46 |    atom_codes(Sx,SxCs), 
47 |    debug(parsing,"~q ~q",[Px,_]). 
48 | 
49 | line(PxCs,SxCs) --> noncomment_prefix(PxCs), `%`, !, arbitrary_suffix(SxCs).
50 | line(PxCs,[])   --> noncomment_prefix(PxCs).
51 | 
52 | noncomment_prefix([C|Cs]) --> [C], { \+ member(C,`%\n\r`) }, !, noncomment_prefix(Cs).
53 | noncomment_prefix([])     --> [].
54 | 
55 | arbitrary_suffix([C|Cs])  --> [C], { \+ member(C,`\n\r`) }, !, arbitrary_suffix(Cs).
56 | arbitrary_suffix([])      --> [].
57 | 
58 | 
59 | 
60 | main :- 
61 |    read_file_to_codes("/home/calvin/_WORK_ON_PROLOG/swiplmaking2/jplwork/packages-jpl/jpl.pl",Cs,[]),
62 |    phrase(file, Cs, []).
63 | 
64 | 
65 | 
66 | 


--------------------------------------------------------------------------------
/swipl_notes/about_dicts/code/applications/count_values_encountered.pl:
--------------------------------------------------------------------------------
 1 | 
 2 | % ==========
 3 | % Demonstrating/Testing SWI-Prolog dicts as described at 
 4 | % https://eu.swi-prolog.org/pldoc/man?section=bidicts
 5 | % ==========
 6 | 
 7 | % Using a dict to count atomic values encountered during processing:
 8 | 
 9 | % ===
10 | % inc(+Key,+DictIn,?DictOut)
11 | % Increment the counter for "Key" in (immutable) dict "DictIn", giving "DictOut".
12 | % If there is not entry for "Key", add a new entry with initial counter value 1.
13 | % This can be used with foldl/N for example.
14 | % ===
15 | 
16 | inc_for_key(Key,DictIn,DictOut) :- 
17 |    (get_dict(Key,DictIn,X) 
18 |     -> 
19 |     succ(X,XP)
20 |     ;
21 |     XP=1), 
22 |    put_dict(Key,DictIn,XP,DictOut).
23 |    
24 | % ===
25 | % Tests
26 | % ===
27 | 
28 | :- begin_tests(inc_for_key).
29 | 
30 | test("just increment for 'a'",true(Do == quux{a:1})) :- 
31 |    Di = quux{}, 
32 |    inc_for_key(a,Di,Do).
33 | 
34 | test("increment for 'a' twice",true(Do == quux{a:2})) :- 
35 |    Di = quux{},
36 |    inc_for_key(a,Di,D2),
37 |    inc_for_key(a,D2,Do).
38 | 
39 | test("increment for 'a' and 'b'",true(Do == quux{a:1,b:1})) :- 
40 |    Di = quux{}, 
41 |    inc_for_key(a,Di,D2),
42 |    inc_for_key(b,D2,Do).
43 | 
44 | :- end_tests(inc_for_key).
45 | 


--------------------------------------------------------------------------------
/swipl_notes/about_dicts/code/applications/selection_for_default_parameters.pl:
--------------------------------------------------------------------------------
 1 | % ==========
 2 | % Demonstrating/Testing SWI-Prolog dicts as described at 
 3 | % https://eu.swi-prolog.org/pldoc/man?section=bidicts
 4 | % ==========
 5 | 
 6 | % ===
 7 | % A simple application of dict selection: Override default parameters with a dict.
 8 | %
 9 | % We pick a value from a possibly large dict full of various parameter/value pairs,
10 | % and fall back to a default value if the parameter doesn't exist.
11 | % ===
12 | 
13 | pick(encoding,Dict,Value) :-
14 |    (_{encoding:Value} :< Dict) -> true ; Value = 'iso-8859-1'.
15 | 
16 | % ---
17 | % Testing the above
18 | % ---
19 | 
20 | :- begin_tests(default_values).
21 |    
22 | test("use default encoding", true(Enc == 'iso-8859-1')) :-
23 |    pick(encoding, _{} , Enc).
24 |    
25 | test("override default encoding", true(Enc == 'utf-8')) :-
26 |    pick(encoding, _{foo:bar, encoding:'utf-8'}, Enc).
27 |         
28 | :- end_tests(default_values).
29 | 


--------------------------------------------------------------------------------
/swipl_notes/about_dicts/code/applications/sum_over_numeric_values.pl:
--------------------------------------------------------------------------------
 1 | 
 2 | % ==========
 3 | % Demonstrating/Testing SWI-Prolog dicts as described at 
 4 | % https://eu.swi-prolog.org/pldoc/man?section=bidicts
 5 | % ==========
 6 | 
 7 | % ===
 8 | % Sum (over keys) the integer values contained in a dictionary using library(aggregate)
 9 | % ===
10 | 
11 | sum_all_values(_{} ,0) :- !.
12 | sum_all_values(Dict,Total) :- 
13 |    aggregate(sum(V), Key^get_dict(Key,Dict,V), Total).
14 | 
15 | % ---
16 | % Testing
17 | % ---
18 | 
19 | :- begin_tests(sum_all_values).
20 | 
21 | test("Sum over empty dict", true(Total == 0)) :- 
22 |    Dict = quux{},
23 |    sum_all_values(Dict,Total).
24 | 
25 | test("Sum over nonempty dict", true(Total == 3)) :- 
26 |    Dict = quux{x:1,y:2},
27 |    sum_all_values(Dict,Total).
28 | 
29 | :- end_tests(sum_all_values).
30 | 


--------------------------------------------------------------------------------
/swipl_notes/about_dicts/code/load_all_run_tests.pl:
--------------------------------------------------------------------------------
1 | load_files([
2 |     'dict_getting_testing.pl'
3 |    ,'dict_unification_testing.pl'
4 |    ,'dict_assembly_disassembly_testing.pl'
5 |    ,'dict_put_dotcall_testing.pl'
6 |    ,'dict_equality_testing.pl'
7 |    ,'dict_selection_testing.pl']), 
8 |    run_tests.
9 | 


--------------------------------------------------------------------------------
/swipl_notes/about_dicts/manual_review/dict_manual_review.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_dicts/manual_review/dict_manual_review.pdf


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/01A.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/01A.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/01B.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/01B.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/02A.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/02A.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/02B.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/02B.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/02C.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/02C.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/02D.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/02D.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/02E.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/02E.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/02F.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/02F.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/03A.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/03A.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/03B.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/03B.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/03C.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/03C.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/03D.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/03D.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/03E.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/03E.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/03F.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/03F.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/04A.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/04A.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/04B.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/04B.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/04C.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/04C.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/04D.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/04D.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/04E.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/04E.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/04F.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/04F.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/05A.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/05A.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/05B.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/05B.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/05C.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/05C.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/05D.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/05D.png


--------------------------------------------------------------------------------
/swipl_notes/about_difference_lists/pics/05E.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_difference_lists/pics/05E.png


--------------------------------------------------------------------------------
/swipl_notes/about_documentation/bibliography/pics/pdflatex-bibtex_pipeline.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_documentation/bibliography/pics/pdflatex-bibtex_pipeline.png


--------------------------------------------------------------------------------
/swipl_notes/about_documentation/pics/editing_process.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_documentation/pics/editing_process.png


--------------------------------------------------------------------------------
/swipl_notes/about_documentation/pics/findall_predicate_banner.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_documentation/pics/findall_predicate_banner.png


--------------------------------------------------------------------------------
/swipl_notes/about_documentation/pics/guillements_example.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_documentation/pics/guillements_example.png


--------------------------------------------------------------------------------
/swipl_notes/about_documentation/pics/quotation_marks.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_documentation/pics/quotation_marks.png


--------------------------------------------------------------------------------
/swipl_notes/about_documentation/pics/result_of_term_dotlists_true.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_documentation/pics/result_of_term_dotlists_true.png


--------------------------------------------------------------------------------
/swipl_notes/about_documentation/pics/result_of_testing_typesetting_empty_list.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_documentation/pics/result_of_testing_typesetting_empty_list.png


--------------------------------------------------------------------------------
/swipl_notes/about_documentation/pics/result_of_typesetting_term.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_documentation/pics/result_of_typesetting_term.png


--------------------------------------------------------------------------------
/swipl_notes/about_exceptions/pics/Java_Exception_Hierarchy.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_exceptions/pics/Java_Exception_Hierarchy.png


--------------------------------------------------------------------------------
/swipl_notes/about_exceptions/pics/prolog_coding_guidelines_exceptions.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_exceptions/pics/prolog_coding_guidelines_exceptions.png


--------------------------------------------------------------------------------
/swipl_notes/about_findall/pics/cover_LNCS238.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_findall/pics/cover_LNCS238.jpg


--------------------------------------------------------------------------------
/swipl_notes/about_findall/pics/cover_art_of_prolog_1st_edition.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_findall/pics/cover_art_of_prolog_1st_edition.jpg


--------------------------------------------------------------------------------
/swipl_notes/about_findall/pics/cover_craft_of_prolog.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_findall/pics/cover_craft_of_prolog.jpg


--------------------------------------------------------------------------------
/swipl_notes/about_findall/pics/cover_programming_in_prolog.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_findall/pics/cover_programming_in_prolog.jpg


--------------------------------------------------------------------------------
/swipl_notes/about_findall/pics/findall_is_pretty_acme.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_findall/pics/findall_is_pretty_acme.jpg


--------------------------------------------------------------------------------
/swipl_notes/about_if_then_else/pics/cut_as_wired_up_in_the_byrd_box_model.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_if_then_else/pics/cut_as_wired_up_in_the_byrd_box_model.png


--------------------------------------------------------------------------------
/swipl_notes/about_if_then_else/pics/if_then_as_wired_up_in_the_byrd_box_model.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_if_then_else/pics/if_then_as_wired_up_in_the_byrd_box_model.png


--------------------------------------------------------------------------------
/swipl_notes/about_if_then_else/pics/if_then_else_as_parsed.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_if_then_else/pics/if_then_else_as_parsed.png


--------------------------------------------------------------------------------
/swipl_notes/about_if_then_else/pics/if_then_else_as_wired_up_in_the_byrd_box_model.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_if_then_else/pics/if_then_else_as_wired_up_in_the_byrd_box_model.png


--------------------------------------------------------------------------------
/swipl_notes/about_if_then_else/pics/if_then_else_as_wired_up_in_the_byrd_box_model_p_fails.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_if_then_else/pics/if_then_else_as_wired_up_in_the_byrd_box_model_p_fails.png


--------------------------------------------------------------------------------
/swipl_notes/about_if_then_else/pics/if_then_else_as_wired_up_in_the_byrd_box_model_p_succeeds.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_if_then_else/pics/if_then_else_as_wired_up_in_the_byrd_box_model_p_succeeds.png


--------------------------------------------------------------------------------
/swipl_notes/about_if_then_else/pics/if_then_else_as_written.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_if_then_else/pics/if_then_else_as_written.png


--------------------------------------------------------------------------------
/swipl_notes/about_if_then_else/pics/or_as_wired_up_in_the_byrd_box_model.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_if_then_else/pics/or_as_wired_up_in_the_byrd_box_model.png


--------------------------------------------------------------------------------
/swipl_notes/about_if_then_else/pics/soft_cut_as_wired_up_in_the_byrd_box_model.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_if_then_else/pics/soft_cut_as_wired_up_in_the_byrd_box_model.png


--------------------------------------------------------------------------------
/swipl_notes/about_if_then_else/pics/soft_cut_as_wired_up_in_the_byrd_box_model_p_fails.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_if_then_else/pics/soft_cut_as_wired_up_in_the_byrd_box_model_p_fails.png


--------------------------------------------------------------------------------
/swipl_notes/about_if_then_else/pics/soft_cut_as_wired_up_in_the_byrd_box_model_p_succeeds.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_if_then_else/pics/soft_cut_as_wired_up_in_the_byrd_box_model_p_succeeds.png


--------------------------------------------------------------------------------
/swipl_notes/about_maplist/README.md:
--------------------------------------------------------------------------------
 1 | # Explainers for Prolog's `maplist/N` predicates
 2 | 
 3 | On this site:
 4 | 
 5 | - [`maplist/2` examples](maplist_2_examples.md) Working off a single list. *Start here!* This includes an explainer on the use of [`library(yall)`](https://eu.swi-prolog.org/pldoc/man?section=yall) lambda expressions and Prolog-style closures.
 6 | - [`maplist/3` examples](maplist_3_examples.md) Relating the elements of two lists. 
 7 | - [`maplist/4` examples](maplist_4_examples.md) Relating the elements of three lists. Relatively little material so far.
 8 | 
 9 | The pages in the SWI Prolog manual are a bit brief:
10 | 
11 | At eu.swi-prolog.org:
12 | 
13 | - `maplist/2` ([eu site](https://eu.swi-prolog.org/pldoc/doc_for?object=maplist/2)) ([www site](https://www.swi-prolog.org/pldoc/doc_for?object=maplist/2))
14 | - `maplist/3` ([eu site](https://eu.swi-prolog.org/pldoc/doc_for?object=maplist/3)) ([www site](https://www.swi-prolog.org/pldoc/doc_for?object=maplist/3))
15 | - `maplist/4` ([eu site](https://eu.swi-prolog.org/pldoc/doc_for?object=maplist/4)) ([www site](https://www.swi-prolog.org/pldoc/doc_for?object=maplist/4))
16 | - `maplist/5` ([eu site](https://eu.swi-prolog.org/pldoc/doc_for?object=maplist/5)) ([www site](https://www.swi-prolog.org/pldoc/doc_for?object=maplist/5))
17 | 


--------------------------------------------------------------------------------
/swipl_notes/about_maplist/webmanualtxt/maplist_2.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=maplist/2
 2 | 
 3 | ## Explainer
 4 | 
 5 | Explainer including examples for the use of maplist/2 (and maplist/3 and maplist/4) here, including on using [`library(yall)`](https://eu.swi-prolog.org/pldoc/man?section=yall) lambda expressions: 
 6 | 
 7 | [**Examples for the Prolog predicate maplist∕2**](https://github.com/dtonhofer/prolog_notes/blob/master/swipl_notes/about_maplist/maplist_2_examples.md), including on how to build the _Goal_.
 8 | 
 9 | ## What if argument 2 is not a list?
10 | 
11 | If the List argument is not a list, then maplist _fails_ instead of throwing.
12 | 
13 | ```
14 | ?- maplist(atom,foo).
15 | false.
16 | ```
17 | 
18 | Prolog predicates are often too lenient, which is actually what is desired in a "logic setting" but may lead to hard-to-find errors.
19 | 
20 | 
21 | 


--------------------------------------------------------------------------------
/swipl_notes/about_mode_indicators/mode_indicators.ods:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_mode_indicators/mode_indicators.ods


--------------------------------------------------------------------------------
/swipl_notes/about_mode_indicators/mode_indicators.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_mode_indicators/mode_indicators.pdf


--------------------------------------------------------------------------------
/swipl_notes/about_mode_indicators/mode_indicators.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_mode_indicators/mode_indicators.png


--------------------------------------------------------------------------------
/swipl_notes/about_operators/pics/parse_tree.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_operators/pics/parse_tree.png


--------------------------------------------------------------------------------
/swipl_notes/about_operators/pics/parse_tree_with_precedence_values.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_operators/pics/parse_tree_with_precedence_values.png


--------------------------------------------------------------------------------
/swipl_notes/about_output_formatting/format_2_cheatsheet/format_2_cheatsheet.ods:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_output_formatting/format_2_cheatsheet/format_2_cheatsheet.ods


--------------------------------------------------------------------------------
/swipl_notes/about_output_formatting/format_2_cheatsheet/format_2_cheatsheet.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_output_formatting/format_2_cheatsheet/format_2_cheatsheet.pdf


--------------------------------------------------------------------------------
/swipl_notes/about_output_formatting/format_2_cheatsheet/format_2_cheatsheet.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_output_formatting/format_2_cheatsheet/format_2_cheatsheet.png


--------------------------------------------------------------------------------
/swipl_notes/about_predicate_structure/falsing_and_error_throwing.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_predicate_structure/falsing_and_error_throwing.png


--------------------------------------------------------------------------------
/swipl_notes/about_salvaging_a_term_out_of_a_dropped_search_branch/pics/simple_straightforward_call_illustration.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_salvaging_a_term_out_of_a_dropped_search_branch/pics/simple_straightforward_call_illustration.png


--------------------------------------------------------------------------------
/swipl_notes/about_swipl_data_types/archive/old/pseudotypes.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_swipl_data_types/archive/old/pseudotypes.png


--------------------------------------------------------------------------------
/swipl_notes/about_swipl_data_types/archive/older/prolog_syntax.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_swipl_data_types/archive/older/prolog_syntax.png


--------------------------------------------------------------------------------
/swipl_notes/about_swipl_data_types/swipl_data_type_tree/swipl_data_type_tree.odt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_swipl_data_types/swipl_data_type_tree/swipl_data_type_tree.odt


--------------------------------------------------------------------------------
/swipl_notes/about_swipl_data_types/swipl_data_type_tree/swipl_data_type_tree.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_swipl_data_types/swipl_data_type_tree/swipl_data_type_tree.pdf


--------------------------------------------------------------------------------
/swipl_notes/about_swipl_data_types/swipl_data_type_tree/swipl_data_type_tree.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_swipl_data_types/swipl_data_type_tree/swipl_data_type_tree.png


--------------------------------------------------------------------------------
/swipl_notes/about_term_analysis_and_construction/term_analysis_construction.ods:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_term_analysis_and_construction/term_analysis_construction.ods


--------------------------------------------------------------------------------
/swipl_notes/about_term_analysis_and_construction/term_analysis_construction.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_term_analysis_and_construction/term_analysis_construction.pdf


--------------------------------------------------------------------------------
/swipl_notes/about_term_analysis_and_construction/term_analysis_construction.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/swipl_notes/about_term_analysis_and_construction/term_analysis_construction.png


--------------------------------------------------------------------------------
/swipl_notes/about_term_analysis_and_construction/test_compound_name_arguments.pl:
--------------------------------------------------------------------------------
 1 | :- begin_tests(compound_name_arguments).
 2 | 
 3 | dict_functor(F) :- compound_name_arguments(_{},F,_).
 4 | 
 5 | test("Disassemble an empty list", error(type_error(compound,[]))) :-
 6 |    compound_name_arguments([],_,_).
 7 | 
 8 | test("Disassemble a one-element list", true(T)) :-
 9 |    compound_name_arguments([a],Functor,Args),
10 |    T = (Functor-Args == '[|]'-[a,[]]).
11 | 
12 | test("Disassemble a three-element list", true(T)) :-
13 |    compound_name_arguments([a,b,c],Functor,Args),
14 |    T = (Functor-Args == '[|]'-[a,[b,c]]).
15 | 
16 | test("Disassemble SWI-Prolog specific compound term of arity 0", true(T)) :-
17 |    compound_name_arguments(a(),Functor,Args),
18 |    T = (Functor-Args == a-[]).
19 | 
20 | test("Disassemble SWI-Prolog specific (named) empty dict", true(T)) :-
21 |    compound_name_arguments(alpha{},Functor,Args),
22 |    dict_functor(F),
23 |    T = (Functor-Args == F-[alpha]).
24 | 
25 | test("Disassemble SWI-Prolog specific (named) dict with two pairs", true(T)) :-
26 |    compound_name_arguments(alpha{x:1,y:2},Functor,Args),
27 |    dict_functor(F),
28 |    T = (Functor-Args == F-[alpha, 1, x, 2, y]).
29 | 
30 | test("Disassemble SWI-Prolog specific (anonymous) dict with two pairs", true(T)) :-
31 |    compound_name_arguments(_{x:1,y:2},Functor,Args),
32 |    dict_functor(F),
33 |    Args = [Tag|Payload],var(Tag),
34 |    T = (Functor-Payload == F-[1, x, 2, y]).
35 | 
36 | :- end_tests(compound_name_arguments).
37 | 


--------------------------------------------------------------------------------
/terms_variables_jargon/README.md:
--------------------------------------------------------------------------------
 1 | # Prolog jargon: terms, variables and all that
 2 | 
 3 | Prolog's terminology seems affected by too much history. 
 4 | 
 5 | There is unaccountable confusion between two domains, namely the syntactic domain (the 
 6 | one in evidence when we talk about source code) and the runtime domain (the one 
 7 | in evidence when we talk about what the running program is doing). One fluidly talks about
 8 | "terms" and "variables" in both domains, but the actual meaning of these words varies
 9 | between these domains, and by quite a bit.
10 | 
11 | Trying to clarify.
12 | 
13 | ![jargon for terms and variables](pics/jargon_for_terms.png)
14 | 
15 | - [ODS format](pics/jargon_for_terms.ods)
16 | - [PDF format](pics/jargon_for_terms.pdf)
17 | 
18 | 
19 | 


--------------------------------------------------------------------------------
/terms_variables_jargon/prolog_lingo/prolog_lingo.ods:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/terms_variables_jargon/prolog_lingo/prolog_lingo.ods


--------------------------------------------------------------------------------
/terms_variables_jargon/prolog_lingo/prolog_lingo.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/terms_variables_jargon/prolog_lingo/prolog_lingo.pdf


--------------------------------------------------------------------------------
/terms_variables_jargon/prolog_lingo/prolog_lingo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/terms_variables_jargon/prolog_lingo/prolog_lingo.png


--------------------------------------------------------------------------------
/third_party_code/plspec-master/.gitignore:
--------------------------------------------------------------------------------
 1 | *.aux
 2 | *.bbl
 3 | *.blg
 4 | *.fdb_latexmk
 5 | *.fls
 6 | *.log
 7 | *.out
 8 | *.pag
 9 | *.pdf
10 | playground.pl
11 | 


--------------------------------------------------------------------------------
/third_party_code/plspec-master/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: objective-c
 2 | 
 3 | before_install:
 4 |   - brew update
 5 |   - brew install swi-prolog
 6 |   - brew outdated swi-prolog || brew upgrade swi-prolog
 7 | 
 8 | script:
 9 |   - cd plspec
10 |   - make tests
11 | 
12 | notifications:
13 |   email:
14 |     - isabel.wingen@hhu.de
15 | 


--------------------------------------------------------------------------------
/third_party_code/plspec-master/LICENSE.md:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Philipp Körner & Sebastian Krings
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/third_party_code/plspec-master/plspec/Makefile:
--------------------------------------------------------------------------------
 1 | tests:
 2 | 	swipl -s plspec_test.pl -g "run_tests,halt."
 3 | 	swipl -s validator_test.pl -g "run_tests,halt."
 4 | 
 5 | sicstusTests:
 6 | 	sicstus -l plspec_test.pl --goal "plspec_test:run_tests,halt."
 7 | 	sicstus -l validator_test.pl --goal "validator_test:run_tests,halt."
 8 | 
 9 | allTests: tests sicstusTests
10 | 


--------------------------------------------------------------------------------
/third_party_code/plspec-master/plspec/plspec_logger.pl:
--------------------------------------------------------------------------------
 1 | :- module(plspec_logger, [log/3, log/2, set_loglevel/1, possible_loglevel/1]).
 2 | 
 3 | possible_loglevel(info).
 4 | possible_loglevel(warning).
 5 | possible_loglevel(error).
 6 | possible_loglevel(debug).
 7 | possible_loglevel(nothing).
 8 | 
 9 | :- dynamic loglevel/1.
10 | set_loglevel(info) :-
11 |   retractall(loglevel(_)),
12 |   assert(loglevel(info)),
13 |   assert(loglevel(error)),
14 |   assert(loglevel(warning)).
15 | 
16 | set_loglevel(warning) :-
17 |   retractall(loglevel(_)),
18 |   assert(loglevel(error)),
19 |   assert(loglevel(warning)).
20 | 
21 | set_loglevel(error) :-
22 |   retractall(loglevel(_)),
23 |   assert(loglevel(error)).
24 | 
25 | set_loglevel(debug) :-
26 |   retractall(loglevel(_)),
27 |   assert(loglevel(debug)),
28 |   assert(loglevel(warning)),
29 |   assert(loglevel(error)),
30 |   assert(loglevel(info)).
31 | 
32 | set_loglevel(nothing) :-
33 |   retractall(loglevel(_)).
34 | 
35 | 
36 | log(X, Format, Args) :-
37 |   (possible_loglevel(X) -> true ; format('~w~t~10 plspec: ~w is not a valid loglevel!', [error, X])),
38 |   (loglevel(X)
39 |     -> format('~w ~w~`.t~20|',[plspec, X, a]), format(Format,Args), nl
40 |     ;  true).
41 | 
42 | log(X, Format) :-
43 |   log(X, Format, []).
44 | 


--------------------------------------------------------------------------------
/third_party_code/plspec-master/plspec/plspec_test.plspec:
--------------------------------------------------------------------------------
1 | :- module(plspec_test_specs, []).
2 | 
3 | :- use_module(plspec).
4 | :- enable_all_spec_checks.
5 | 
6 | :- spec_pre(plspec_test:this_pred_has_an_extern_spec/1, [int]).
7 | 


--------------------------------------------------------------------------------
/third_party_code/plspec-master/plspec/tests.pl:
--------------------------------------------------------------------------------
1 | :- use_module(library(test_cover)).
2 | 
3 | :- [plspec_test].
4 | :- [validator_test].
5 | :- [preserve_behaviour_test].
6 | :- [unbound_spec_test].
7 | 


--------------------------------------------------------------------------------
/third_party_code/plspec-master/plspec/unbound_spec_test.pl:
--------------------------------------------------------------------------------
 1 | :- use_module(plspec_core).
 2 | :- use_module(library(plunit)).
 3 | :- set_loglevel(debug).
 4 | 
 5 | :- enable_all_spec_checks.
 6 | 
 7 | :- defspec(tree(X), one_of([compound(node(tree(X), X, tree(X))),
 8 |                             atom(empty)])).
 9 | 
10 | :- asserta(validator:spec_predicate(f, atom(f))).
11 | :- asserta(validator:spec_predicate(g, atom(g))).
12 | :- defspec(f_or_g, one_of([f,g])).
13 | 
14 | :- spec_pre(fun/2, [X,X]).
15 | fun(_,_).
16 | 
17 | :- begin_tests(unify_order, [setup(plspec:set_error_handler(throw)), cleanup(plspec:set_error_handler(plspec_default_error_handler))]).
18 | 
19 | 
20 | test(fun_test) :-
21 |     fun(f,g).
22 | 
23 | :- end_tests(unify_order).
24 | 
25 | :- spec_post(reverse_order/2, [tuple([X,Y]), var], [tuple([X,Y]), tuple([Y,X])]).
26 | reverse_order([H|T],S) :-
27 |     reverse_order(T,[H],S).
28 | 
29 | reverse_order([],Res,Res) :- !.
30 | reverse_order([H|T],Buffer,S) :-
31 |     reverse_order(T,[H|Buffer],S).
32 | 


--------------------------------------------------------------------------------
/third_party_code/snippets/O Keefe's flatten.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | 
 3 | flattenList(L,FL) :-
 4 |    must_be(list,L),       % if L is unbound, the predicate does not terminate; make sure it's a list
 5 |    flattenList(L,[],FL).
 6 | 
 7 | % ===
 8 | % flattenList(+In, +Suffix, +Flattened)
 9 | %
10 | % "'Flattened' is the flattened 'In' (which is [In] if 'In' is not a list),
11 | % with the list 'Suffix' suffixed.
12 | % ===
13 | 
14 | flattenList([],Suf,Suf).
15 | 
16 | flattenList([H|T],Suf,Flat):- 
17 |    flattenList(T,Suf,LargerSuf),
18 |    flattenList(H,LargerSuf,Flat).
19 | 
20 | flattenList(H,Suf,[H|Suf]):- \+ is_list(H).
21 | 


--------------------------------------------------------------------------------
/vivid_logic/README.md:
--------------------------------------------------------------------------------
 1 | # Vivid Logic
 2 | 
 3 | Some notes based on the book:
 4 | 
 5 | ![LNAI 764](pics/lnai764cover.png)
 6 | 
 7 | **Vivid Logic: Knowledge-Based Reasoning with Two Kinds of Negation**
 8 | 
 9 | - Gerd Wagner
10 | - Lecture Notes in Artificial Intelligence 764
11 | - Springer Verlag Berlin Heidelberg 1994
12 | - https://www.springer.com/gp/book/9783540576044
13 | 
14 | For some reason I got ahold of the copy of the Universitätsbibliothek Paderborn. A historical artifact!
15 | 
16 | The following paper is a chapter of the above:
17 | 
18 | [Logic programming with strong negation and inexact predicates](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.975.3445&rank=1)
19 | 
20 | - Gerd Wagner
21 | - 1991
22 | - 2do. Congreso Argentino de Ciencias de la Computación
23 | 
24 | 
25 | 


--------------------------------------------------------------------------------
/vivid_logic/pics/lnai764cover.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dtonhofer/prolog_notes/45f15e13a093c7ea8da5f90f6af662592f7bd891/vivid_logic/pics/lnai764cover.png


--------------------------------------------------------------------------------
/website_comment_texts/call_with_depth_limit.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=call_with_depth_limit/3
 2 | 
 3 | ## Examples
 4 | 
 5 | true/0 needs depth 1:
 6 | 
 7 | ```
 8 | ?- call_with_depth_limit(true,0,R).
 9 | R = depth_limit_exceeded.
10 | 
11 | ?- 
12 | call_with_depth_limit(true,1,R).
13 | R = 1.
14 | ```
15 | 
16 | So does false/0:
17 | 
18 | ```
19 | ?- call_with_depth_limit(false,0,R).
20 | R = depth_limit_exceeded.
21 | 
22 | ?- call_with_depth_limit(false,1,R).
23 | false.
24 | ```
25 | 
26 | So does is_list/1
27 | 
28 | ```
29 | ?- call_with_depth_limit(is_list([a,b,c]),1,R).
30 | R = 1.
31 | ```
32 | 
33 | random_between/3 needs depth 2:
34 | 
35 | ```
36 | ?- call_with_depth_limit(=random_between=(0,100,X1),1,R).
37 | R = depth_limit_exceeded.
38 | 
39 | ?- call_with_depth_limit(random_between(0,100,X1),2,R).
40 | X1 = 72,
41 | R = 2.
42 | ```
43 | 
44 | ## It's stacked!
45 | 
46 | A call_with_depth_limit/3 within a call_with_depth_limit/3 does **not** work in a "limited by both" fashion.
47 | 
48 | Instead, while the inner call_with_depth_limit/3 is active, it's the one which counts, and the outer limit is disregarded. Once the Prolog processor backs out of the inner call_with_depth_limit/3 due to excessive depth, failure or success, the outer call_with_depth_limit/3 is in effect again.
49 | 
50 | ## How about tail call optimization?
51 | 
52 | Apparently the mechanism behind call_with_depth_limit continues to count up on calls that are subject to tail-call optimization. 
53 | 
54 | This is what one wants.
55 | 
56 | See the test code below which can be nicely optimized but which is still properly limited.
57 | 
58 | ## Some code for experiments
59 | 
60 | [deeper.pl](https://github.com/dtonhofer/prolog_notes/blob/master/swipl_notes/about_call_with_depth_limit/code/deeper.pl)
61 | 


--------------------------------------------------------------------------------
/website_comment_texts/char_type.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=char_type/2
 2 | 
 3 | What is both in the class "white" and "space"?
 4 | 
 5 | ```
 6 | ?- 
 7 | bagof(Char-Hex,
 8 |    Code^(char_type(Char,space),
 9 |          atom_codes(Char,Code]),
10 |          format(atom(Hex),"0x~|~`0t~16r~4+",[Code])),
11 |    Bag).
12 | 
13 | Bag = [
14 |    '\t'-'0x0009', % (horizontal) tab
15 |    '\n'-'0x000a', % line feed
16 |    '\v'-'0x000b', % vertical tab 
17 |    '\f'-'0x000c', % form feed 
18 |    '\r'-'0x000d', % carriage return
19 |    ' '-'0x0020',  % the "SPACE" character, more correctly the "blank" character 
20 |    ' '-'0x1680',  % Ogham Space Mark
21 |    ' '-'0x2000',  % EN QUAD
22 |    ' '-'0x2001',  % EM QUAD
23 |    ' '-'0x2002',  % EN SPACE
24 |    ' '-'0x2003',  % EM SPACE
25 |    ' '-'0x2004',  % THREE-PER-EM SPACE
26 |    ' '-'0x2005',  % FOUR-PER-EM-SPACE
27 |    ' '-'0x2006',  % SIX-PER-EM SPACE
28 |    ' '-'0x2008',  % FIGURE SPACE
29 |    ' '-'0x2009',  % THIN SPACE
30 |    ' '-'0x200a',  % HAIR SPACE
31 |    '
'-'0x2028',   % LINE SEPARATOR
32 |    '
'-'0x2029',   % PARAGRAPH SEPARATOR
33 |    ' '-'0x205f',  % MEDIUM MATHEMATICAL SPACE
34 |    '　'-'0x3000']. % IDEOGRAPHIC SPACE
35 | ```
36 | 
37 | Where is the "non-breakable sapce" 0x00A0?
38 | 
39 | Amazingly, it's neither "white" nor "space", at least on GNU/Linux Fedora 33:
40 | 
41 | ```
42 | ?- code_type(0xA0,T).
43 | T = graph ;
44 | T = punct ;
45 | T = to_lower(160) ;
46 | T = to_upper(160) ;
47 | false.
48 | ```
49 | 
50 | Well, that's not right, here is the offical list:
51 | 
52 | https://util.unicode.org/UnicodeJsps/list-unicodeset.jsp?a=%5B:General_Category=Space_Separator:%5D
53 | 
54 | SWI-Prolog probably uses something out of the C library here.
55 | 
56 | On Windows:
57 | 
58 | ```
59 | ?- code_type(0xA0,T).
60 | T = space ;
61 | T = to_lower(160) ;
62 | T = to_upper(160) ;
63 | false.
64 | ```
65 | 
66 | 


--------------------------------------------------------------------------------
/website_comment_texts/current_module.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=current_module/1
 2 | 
 3 | ## Example
 4 | 
 5 | ```
 6 | ?- setof(M,current_module(M),Modules).
 7 | Modules = [ansi_term,apply,apply_macros,base32,dcg_basics,editline,error|...].
 8 | ```
 9 | 
10 | ## Sadly!
11 | 
12 | Sadly, this is **not at all** about getting the module of the currently executing code.
13 | 
14 | That's something that is just missing. Something like
15 | 
16 | =|this_module(M)|=
17 | 
18 | would be useful to get at the qualifier which may have to be passed to predicates in other modules.
19 | 
20 | ## Do not be confused
21 | 
22 | Note that there is also a
23 | 
24 | [`current_module/2`](https://eu.swi-prolog.org/pldoc/doc_for?object=backward_compatibility%3Acurrent_module/2)
25 | 
26 | =|current_module(?Module, ?File)|= : True if Module is a module loaded from File.
27 | 
28 | which is a deprecated version of `module_property(Module, file(File))`
29 | 
30 | 


--------------------------------------------------------------------------------
/website_comment_texts/dif.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=dif/2
 2 | 
 3 | ## Needs text improvement
 4 | 
 5 | We read:
 6 | 
 7 | _Finally, if A and B can unify, goals are delayed that prevent A and B to become equal._
 8 | 
 9 | This doesn't _really_ make sense to me. There is nothing that is "delayed" really, it's just that a background check is done if A and B are involved in a unification. That description really threw me off.
10 | 
11 | (With hindsight and after getting into the jargon one realizes that "goals are delayed"  might well mean "a procedure will be run asynchronously" ... "to make sure that A and B do not become equal". But a reference manual should not be a grimoire.)
12 | 
13 | The text in [`library(dif)`](https://eu.swi-prolog.org/pldoc/doc/_SWI_/library/dif.pl) is much clearer:
14 | 
15 | _Among the most important coroutining predicates is dif/2, which expresses disequality of terms in a sound way. The actual test is delayed until the terms are sufficiently different, or have become identical._
16 | 
17 | I prefer to look at it this way:
18 | 
19 | _After a `dif(A,B)` call, any unification involving `A` or `B` or subterms thereof
20 | that would make `A` and `B` identical (`A == B`) will **fail** (and this applies to unification in clause heads, too)._
21 | 
22 | _If `A` and `B` are already identical at call time, `dif(A,B)` fails at once._
23 | 
24 | ## Writeup on `dif`
25 | 
26 | I made a writeup, including examples, here:
27 | 
28 | [**About dif/2**](https://github.com/dtonhofer/prolog_notes/tree/master/swipl_notes/about_dif).
29 | 
30 | That has turned into a lot of text, hopefully clear.
31 | 


--------------------------------------------------------------------------------
/website_comment_texts/doc_needs_help.md:
--------------------------------------------------------------------------------
 1 | # Doc needs help
 2 | 
 3 | - https://eu.swi-prolog.org/pldoc/doc_for?object=is_list/1
 4 | - https://eu.swi-prolog.org/pldoc/doc_for?object=(%3D%3D)/2
 5 | - Add some notes onto compound_name-arity and compound_name-arguments and is_dic according to https://swi-prolog.discourse.group/t/edge-case-dicts-and-compound-name-arity-3/2685/3
 6 | - https://eu.swi-prolog.org/pldoc/man?predicate=atomic/1
 7 | - https://www.swi-prolog.org/pldoc/man?section=ext-blockop
 8 | - https://eu.swi-prolog.org/pldoc/doc_for?object=compound_name_arity/3
 9 | - https://eu.swi-prolog.org/pldoc/doc_for?object=compound_name_arguments/3
10 | - https://eu.swi-prolog.org/pldoc/doc_for?object=arg/3 "fail silently"
11 | - https://eu.swi-prolog.org/pldoc/doc_for?object=copy_term/2 "renamed fresh variables"
12 | - https://eu.swi-prolog.org/pldoc/doc_for?object=compound_name_arguments/3
13 | - https://eu.swi-prolog.org/pldoc/doc_for?object=arg/3 Better Args
14 | - https://eu.swi-prolog.org/pldoc/doc_for?object=setarg/3
15 | - https://eu.swi-prolog.org/pldoc/doc_for?object=repeat/0
16 | - https://eu.swi-prolog.org/pldoc/doc_for?object=split_string/4
17 | - https://github.com/dtonhofer/prolog_notes/issues/1
18 | - https://eu.swi-prolog.org/pldoc/man?section=testassertion
19 | - https://eu.swi-prolog.org/pldoc/man?predicate=call/1
20 | - https://eu.swi-prolog.org/pldoc/man?section=db
21 | 


--------------------------------------------------------------------------------
/website_comment_texts/exists_file.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=exists_file/1
 2 | 
 3 | An example:
 4 | 
 5 | We have a directory, an actual file, and a symlink to a file and to a directory:
 6 | 
 7 | ```
 8 | .
 9 | ├── actual_directory/
10 | ├── actual_file
11 | ├── symlink_to_directory -> actual_directory
12 | └── symlink_to_file -> actual_file
13 | ```
14 | 
15 | Then:
16 | 
17 | ```
18 | ?- exists_file(actual_directory).
19 | false.
20 | 
21 | ?- exists_file(actual_file).
22 | true.
23 | 
24 | ?- exists_file(symlink_to_directory).
25 | false.
26 | 
27 | ?- exists_file(symlink_to_file).
28 | true.
29 | 
30 | ?- exists_file(yappadappadoowilmaaa).
31 | false.
32 | ```
33 | 
34 | This seems to behave like the Perl `-f` file test flag, see:
35 | 
36 | https://perldoc.perl.org/functions/-X
37 | 
38 | ```
39 | $ perl -e 'if (-f "actual_directory") { print "YES\n" } else { print "NO\n" }'
40 | NO
41 | 
42 | $ perl -e 'if (-f "symlink_to_directory") { print "YES\n" } else { print "NO\n" }'
43 | NO
44 | 
45 | $ perl -e 'if (-f "symlink_to_file") { print "YES\n" } else { print "NO\n" }'
46 | YES
47 | 
48 | $ perl -e 'if (-f "actual_file") { print "YES\n" } else { print "NO\n" }'
49 | YES
50 | 
51 | $ perl -e 'if (-f "yappadappadoowilmaaa") { print "YES\n" } else { print "NO\n" }'
52 | NO
53 | ```
54 | 
55 | Here is a radical idea: why not dump the C straightjacket and become more Perlish:
56 | 
57 | ```
58 | filetest(+Flag,+File)
59 | ```
60 | 
61 | would succeed or fail depending on whether the Perl flag `Flag` applies. That sounds like a powerful addition. 
62 | 
63 | 


--------------------------------------------------------------------------------
/website_comment_texts/findall_3.txt:
--------------------------------------------------------------------------------
1 | ## Notes about findall
2 | 
3 | [**Notes about findall/3**](https://github.com/dtonhofer/prolog_notes/blob/master/swipl_notes/about_findall/README.md) ... how to use it etc. 
4 | 


--------------------------------------------------------------------------------
/website_comment_texts/foldl.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=foldl/4
 2 | 
 3 | ## Doc needs help
 4 | 
 5 | The example says: 
 6 | 
 7 | > the last two arguments [of foldl/4-7] form a typical difference pair
 8 | 
 9 | That's definitely not right. These values may not even be lists! They form the start and the end of a data-flowing "accumulator" chain though.
10 | 
11 | ## Companion README 
12 | 
13 | A companion README with several examples (and an implementation of `foldr/4`) [**can be found here**](https://github.com/dtonhofer/prolog_notes/blob/master/swipl_notes/about_foldl/README.md)
14 | 
15 | ## Super Simple Explainer
16 | 
17 | The key is: `foldl(Goal,[a,b,c,d],Starter,Final)` sets up a dataflow pipeline like this:
18 | 
19 | ==
20 | Starter -->--Goal-->--Goal-->--Goal-->--Goal-->--Final
21 |               ^        ^        ^        ^
22 |               |        |        |        | 
23 |           [   a   ,    b   ,    c   ,    d  ]
24 | ==
25 | 
26 | And `Goal` is called with parameters whose name should be this:
27 | 
28 | ==
29 | Goal(Element,FromLeft,ToRight)                              for single list
30 | Goal(Element1,Element2,FromLeft,ToRight)                    for two lists
31 | Goal(Element1,Element2,Element3,FromLeft,ToRight)           for three lists
32 | Goal(Element1,Element2,Element3,Element4,FromLeft,ToRight)  for four lists
33 | ==
34 | 
35 | ... and that's all one really needs to know.
36 | 


--------------------------------------------------------------------------------
/website_comment_texts/get_time.txt:
--------------------------------------------------------------------------------
 1 | Returns a float!
 2 | 
 3 | Compare with Unix `date` command's "seconds since 1970-01-01 00:00:00 UTC" (watch out for the difference in leap seconds between actual UTC and [Unix time](https://en.wikipedia.org/wiki/Unix_time) and the difference between [TAI](https://en.wikipedia.org/wiki/International_Atomic_Time) and UTC).
 4 | 
 5 | ==
 6 | ?- get_time(T),float(T),process_create('/usr/bin/date',['+%s'],[]).
 7 | 1604652321  
 8 | T = 1604652321.0266113.
 9 | ==
10 | 
11 | **The naming is ... lousy**
12 | 
13 | It should be an arithmetic function and it should be written:
14 | 
15 | ==
16 | T is the_time()
17 | ==
18 | 
19 | possibly
20 | 
21 | ==
22 | T is the_time_of(now)
23 | == 
24 | 
25 | which would make much more sense.
26 | 
27 | 
28 | `get_time(T)` reads as
29 | 
30 |    - "`get_time` is an attribute of T", or
31 |    - "Find me a T so that get_time(T) is true" (there is no such T, really)
32 | 


--------------------------------------------------------------------------------
/website_comment_texts/is_list.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=is_list/1
 2 | 
 3 | ## Doc error
 4 | 
 5 | "a term with functor `[|]` and arity 2" is slightly incorrect.
 6 | 
 7 | The functor _is_ `[|]` / 2 i.e. the functor includes the arity.
 8 | 
 9 | The [ISO definition](https://stackoverflow.com/questions/49898738/is-this-prolog-terminology-correct-fact-rule-procedure-predicate) says "functor: An identifier together with an arity."
10 | 
11 | Better:
12 | 
13 | "a term with name/identifier `[|]` and arity 2"
14 | 
15 | ## Unit tests
16 | 
17 | Some unit tests for this predicate:
18 | 
19 | [`test_is_list.pl`](https://github.com/dtonhofer/prolog_notes/blob/master/code_unit_tests/builtin_demo/test_is_list.pl)
20 | 
21 | ## Checking for an openlist
22 | 
23 | As used in "difference lists", an **open list** has a "hole" at the last position (denoted by a variable), what I call "Fin", instead of the "empty list" atomic constant:
24 | 
25 | ==
26 | List1    = [1,2,3|[]]
27 | List2    = [1,2,3]      % same as List1
28 | OpenList = [1,2,3|_]    % freshvar at Fin position
29 | OpenList = [1,2,3|Fin]  % name the freshvar
30 | ==
31 | 
32 | Like this.
33 | 
34 |    - **proper/closed list** on the left
35 |    - **open list** on the right
36 | 
37 | ==
38 | List ------->[|]                  [|]<-------------- OpenList
39 |             /   \                /   \
40 |            1    [|]             1    [|]
41 |                /   \                /   \
42 |               2    [|]             2    [|]
43 |                   /   \                /   \
44 |                  3     []             3   ~hole~ <--- Fin
45 | ==
46 | 
47 | A predicate `is_openlist/1` can be found here:
48 | 
49 | [`openlist_append.pl`](https://github.com/dtonhofer/prolog_notes/blob/master/code/heavycarbon/utils/openlist_append.pl)
50 | 
51 | with unit tests:
52 | 
53 | [`openlist_append.plt`](https://github.com/dtonhofer/prolog_notes/blob/master/code/heavycarbon/utils/openlist_append.plt)
54 | 
55 | 


--------------------------------------------------------------------------------
/website_comment_texts/library_strings.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/man?section=strings
 2 | 
 3 | This is a good way to implement [Here Documents](https://en.wikipedia.org/wiki/Here_document) (i.e. text directly included in the source, possibly subject to "interpolation" of variables) in Prolog.
 4 | 
 5 | For quasi-quotation syntax as used here (defined for the keyword `string`), see
 6 | 
 7 | [`library(quasiquotations)`](https://eu.swi-prolog.org/pldoc/man?section=quasiquotations)
 8 | 
 9 | Another attempt at test code in SWI-Prolog 8.3.9:
10 | 
11 | ```
12 | :- use_module(library(strings)).
13 |   
14 | :- begin_tests(here_document).
15 | 
16 | test("generate greeting",true(TXT == 'Dear Perl Developer,\n\nI\'m happy to announce a\nstring interpolation quasi quoter\nfor Prolog!\n')) :-
17 |     [To,Lang] = ["Perl Developer","Prolog"],
18 |     with_output_to(atom(TXT),
19 |        write({|string(To,Lang)||
20 |               | Dear {To},
21 |               |
22 |               | I'm happy to announce a
23 |               | string interpolation quasi quoter
24 |               | for {Lang}!
25 |               |})),
26 |     format("~w\n",[TXT]).
27 |     
28 | :- end_tests(here_document).
29 | ```
30 | 
31 | 


--------------------------------------------------------------------------------
/website_comment_texts/min.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=f(min/2)
 2 | 
 3 | ## Possible extension
 4 | 
 5 | This should really be extended to take vectors:
 6 | 
 7 | ==
 8 | Min is min(ListOfExpressions).
 9 | ==
10 | 
11 | as in
12 | 
13 | ==
14 | Min is min([1,-1,X*44,Y-3]).
15 | ==
16 | 
17 | ## A min/max predicate over dicts
18 | 
19 | Sometimes one has a set of pairs Key-Value and one wants to find the pair with the extremal value (either max or min) and _also_ know the corresponding key:
20 | 
21 | ==
22 | ?-  min_entry_of_dict(_{a:1,b:2,c:3,d:1,e:1,f:5},K,V).
23 | K = a,
24 | V = 1.
25 | 
26 | ?- max_entry_of_dict(_{a:3,b:5,c:4},K,V).
27 | K = b,
28 | V = 5.
29 | 
30 | ?- extremal_entry_of_dict(_{a:1,b:2,c:3,d:1,e:1,f:5},K,V,min,latest).
31 | K = e,
32 | V = 1.
33 | ==
34 | 
35 | And so, code: [`extremal.pl`](https://github.com/dtonhofer/prolog_notes/blob/master/prolog_exercises/extremal.pl)
36 | 
37 | This totally does not use function `min/2` or function `max/2` at all. 
38 | 
39 | (Why isn't there a special notation to distinguish functions from predicates anyway? One could write `min/~2` for example.)
40 | 


--------------------------------------------------------------------------------
/website_comment_texts/multifile.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=(multifile)/1
 2 |  
 3 | Also see this Logtalk blogpost:
 4 | 
 5 | [Multifile predicates: dos and don'ts](https://logtalk.org/2019/06/25/multifile-predicates-dos-donts.html)
 6 | 
 7 | (via Stack Overflow question [A cross-module “interface” call in SWI-Prolog](https://stackoverflow.com/questions/66146716/a-cross-module-interface-call-in-swi-prolog))
 8 | 
 9 |    - never rely on the order of the multifile predicate clauses
10 |    - avoid cuts in multifile predicate definitions. I.e. avoid making assumptions about the predicate calling the multifile predicate and about other multifile predicate definitions.
11 |    - the body of a multifile predicate clause is compiled in the context of the entity containing the clause.
12 |    - In the presence of Prolog modules or when using Logtalk objects, multifile predicates can be declared and defined in modules and objects. In this case, there’s an entity that holds the multifile predicate **primary declaration** and other entities defining clauses for the predicate. Other entities defining clauses for the multifile predicate, will need to prefix the predicate functor with the name of the entity containing its primary declaration (i.e. in SWI Prolog, qualify it with the module name; but SWI-Prolog seems relaxed about this, a bit too much maybe).
13 | 
14 | 
15 | 
16 | 


--------------------------------------------------------------------------------
/website_comment_texts/nb_setarg.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=nb_setarg/3
 2 | 
 3 | A problem from Stack Overflow:
 4 | 
 5 | [Unexpected result for predicate nb_setarg/3](https://stackoverflow.com/questions/65158752/unexpected-result-for-predicate-nb-setarg-3)
 6 | 
 7 | Consider this forall/2
 8 | 
 9 | ```
10 | ?- 
11 | functor(A, array, 5),              % Build A=array(_,_,_,_,_)
12 | forall(
13 |    arg(Index, A, foo),             % forall generator instantiates A[Index] to 'foo'
14 |    nb_setarg(Index, A, bar)).      % forall test nb-sets the same place to 'bar'
15 | A = array(_16050, _16052, _16054, _16056, _16058).
16 | ```
17 | 
18 | The above is expected as backtracking occurs to before the position where `array` at position `Index` is set to `foo`, rolling back the `nb_setarg/3` effect by rolling back the `arg/3` effect.
19 | 
20 | However, the equivalent code below behaves differently (SWI-Prolog 8.2.23):
21 | 
22 | ```
23 | ?- 
24 | A=array(_,_,_,_,_), 
25 | forall(
26 |    arg(Index, A, foo), 
27 |    nb_setarg(Index, A, bar)).
28 | A = array(bar, bar, bar, bar, bar).
29 | ```
30 | 
31 | This is probably unexpected.
32 | 
33 | This one doesn't do "instantiation + nb-set" and so comes out right:
34 | 
35 | ```
36 | ?- 
37 | functor(A, array, 5), 
38 |   forall(
39 |      between(1,5,Index),   
40 |      nb_setarg(Index, A, bar)).
41 | A = array(bar, bar, bar, bar, bar).
42 | ```
43 | 
44 | ```
45 | ?-
46 | A=array(_,_,_,_,_), 
47 | forall(
48 |    between(1,5,Index),   
49 |    nb_setarg(Index, A, bar)).
50 | A = array(bar, bar, bar, bar, bar).
51 | ```
52 | 
53 | Basically, do not backtrack to before where you started using `nb_*` and only use the `nb_*` predicates on the same location.
54 | 
55 | 


--------------------------------------------------------------------------------
/website_comment_texts/nonground.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=nonground/2
 2 | 
 3 | Grabbing an unbound variable from the term that appears as argument 1:
 4 | 
 5 | **Standard usage** 
 6 | 
 7 | ```
 8 | ?- nonground(f(_),K).
 9 | true.
10 | 
11 | ?- nonground(f(X,_,_),K).
12 | X = K.
13 | ```
14 | 
15 | **Failure if first argument is ground**
16 | 
17 | ```
18 | ?- nonground(f(x),K).
19 | false.
20 | ```
21 | 
22 | **Unusual usage**
23 | 
24 | ```
25 | ?- nonground(f(X),X).
26 | true.
27 | ```
28 | 
29 | **Unusual usage leading to instantiation of argument 1**
30 | 
31 | ```
32 | ?- nonground(f(X,Y,_),Y).
33 | X = Y.
34 | ```
35 | 
36 | **This violates the mode. Weird things happen**
37 | 
38 | ```
39 | ?- nonground(f(X,_,_),foo).
40 | F = foo.
41 | ```
42 | 


--------------------------------------------------------------------------------
/website_comment_texts/not_unifies.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=(%5C%3D)/2
 2 | 
 3 | ```
 4 | X = Y
 5 | ```
 6 | 
 7 | means:
 8 | 
 9 | "Proceeding down this path of computation, =|X|= and =|Y|= designate the same thing"
10 | 
11 | But 
12 | 
13 | ```
14 | X \= Y
15 | ```
16 | 
17 | means:
18 | 
19 | "Unify =|X|= and =|Y|= and if this succeeds, fail (rolling the unification back)"
20 | 
21 | or alternatively
22 | 
23 | "If =|X|= and =|Y|= can designate the same thing **at this instant of the computation**, fail"
24 | 
25 | This is suspect. If =|X|= and =|Y|= are unbound the question whether they designate the same thing is ill-defined. We just don't know! This can also happen if the terms are non-ground. Still, we fail. IMHO, Prolog should throw as replacement for the missing "don't know" truth value:
26 | 
27 | ```
28 | ?- X \= Y.
29 | false.
30 | 
31 | ?- f(X) \= f(Y).
32 | false.
33 | ```
34 | 
35 | On the other hand, these queries makes sense:
36 | 
37 | Definitely "the same thing":
38 | 
39 | ```
40 | ?- f(a) \= f(a).
41 | false.
42 | ```
43 | 
44 | Definitely "not the same thing":
45 | 
46 | ```
47 | ?- f(_) \= g(_).
48 | true.
49 | 
50 | ?- f(a) \= f(b).
51 | true.
52 | ```
53 | 
54 | Using
55 | 
56 | =|dif(X,Y)|=
57 | 
58 | means:
59 | 
60 | "Proceeding down this path of computation, =|X|= and =|Y|= cannot designate the same thing"
61 | 
62 | i.e. if we don't know we still proceed, and any attempt at making =|X|= and =|Y|= designate the same thing will fail (i.e. the unification that would entail sameness will fail) and another path of computation will be taken. Much saner.
63 | 
64 | ```
65 | ?- dif(X,Y).
66 | dif(X,Y).     <--- The residual unresolved constraint is printed out here
67 | 
68 | ?- dif(X,Y),write("#1"),X=foo,write("#2"),(Y=foo;Y=bar).
69 | #1#2
70 | X = foo,
71 | Y = bar.
72 | ```
73 | 


--------------------------------------------------------------------------------
/website_comment_texts/obtaining_runtime_statistics.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/man?section=statistics
 2 | 
 3 | There is some functionality for statistics which is hard to find in the manual.
 4 | 
 5 | This chapter, [**Obtaining Runtime Statistics**](https://eu.swi-prolog.org/pldoc/man?section=statistics), lists the following predicates:
 6 | 
 7 |    - statistics/2 - a built-in predicate
 8 |    - statistics/0 - a predicate from =|library(statistics)|=
 9 |    - time/1       - a predicate from =|library(statistics)|=
10 | 
11 | The fact that the predicates are part of =|library(statistics)|= is shown in the header of the page, but the corresponding link directs back to [Obtaining Runtime Statistics](https://eu.swi-prolog.org/pldoc/man?section=statistics), not to =|library(statistics)|=
12 | 
13 | =|library(statistics)|= does not show up in the search bar, but can be found as:
14 | 
15 | [=|library(statistics)|=](https://eu.swi-prolog.org/pldoc/doc/_SWI_/library/statistics.pl). 
16 | 
17 | The lead-in text says: 
18 | 
19 | > The predicates of this library are for human use at the toplevel: information is _printed_. 
20 | 
21 | It provides the following, two of which are listed above
22 | 
23 |    - statistics/0 (as seen above) ; [alt documentation link](https://eu.swi-prolog.org/pldoc/doc_for?object=prolog_statistics%3Astatistics/0) - Printout for the user
24 |    - statistics/1 - Collect **all** performance values into a dict for further processing
25 |    - thread_statistics/3  
26 |    - time/1 (as seen above)  ; [alt documentation link](https://eu.swi-prolog.org/pldoc/doc_for?object=prolog_statistics%3Atime/1) - Time a goal, printout for the user
27 |    - call_time/2 
28 |    - call_time/3 
29 | 
30 | The chapter, [**Execution Profiling**](https://eu.swi-prolog.org/pldoc/man?section=profile) is separate and lists further predicates provided by =|library(statistics)|=:
31 | 
32 |    - profile/1
33 |    - profile/2
34 |    - show_profile/1
35 |    - profile_data/1
36 |    - profile_procedure_data/2
37 | 
38 | 


--------------------------------------------------------------------------------
/website_comment_texts/once.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=once/1
 2 |  
 3 | ## Personal opinion
 4 | 
 5 | Definitely prefer once/1 over ->/2. 
 6 | 
 7 | It makes the intent clear and, unlike ->/2, is actually readable.
 8 | 
 9 | ## Don't get confused
10 | 
11 | Note that this is absolutely not the same as using "cut":
12 | 
13 | With
14 | 
15 | ```
16 | foo(A,B) :- member(A-B,[a-1,b-2,c-3,a-4]).
17 | foo(A,B) :- member(A-B,[d-5,e-6,a-7,f-8]).
18 | ```
19 | 
20 | we have:
21 | 
22 | ```
23 | ?- foo(a,B).
24 | B = 1 ;
25 | B = 4 ;
26 | B = 7 ;
27 | false.
28 | ```
29 | 
30 | Once-ify the first clause:
31 | 
32 | ```
33 | foo(A,B) :- once(member(A-B,[a-1,b-2,c-3,a-4])).
34 | foo(A,B) :- member(A-B,[d-5,e-6,a-7,f-8]).
35 | ```
36 | 
37 | Then:
38 | 
39 | ```
40 | ?- foo(a,B).
41 | B = 1 ;
42 | B = 7 ;
43 | false.
44 | ```
45 | 
46 | But if you cut at the end of the first clause:
47 | 
48 | ```
49 | foo(A,B) :- member(A-B,[a-1,b-2,c-3,a-4]),!.
50 | foo(A,B) :- member(A-B,[d-5,e-6,a-7,f-8]).
51 | ```
52 | 
53 | You get:
54 | 
55 | ```
56 | ?- foo(a,B).
57 | B = 1.
58 | ```
59 | 
60 | ## Where is twice/1 ?
61 | 
62 | If there is a =once/1=, there should probably be a =twice/1= etc.
63 | 
64 | And there is: limit/2 from [library(solution_sequences)](https://eu.swi-prolog.org/pldoc/doc/_SWI_/library/solution_sequences.pl)
65 | 


--------------------------------------------------------------------------------
/website_comment_texts/option_3.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=option/3
 2 | 
 3 | It's about the value found in the term:
 4 | 
 5 | ==
 6 | ?- option(foo(X),[],none).
 7 | X = none.
 8 | ==
 9 | 
10 | Do not specify the whole expected term as default:
11 | 
12 | ==
13 | ?- option(foo(X),[],foo(none)).
14 | X = foo(none).
15 | ==
16 | 
17 | As expected, if an option with a value exists, that value is used instead:
18 | 
19 | ==
20 | ?- option(foo(X),[foo(yes)],none).
21 | X = yes.
22 | ==
23 | 
24 | A bit weirdish:
25 | 
26 | ==
27 | ?- option(foo(yes),[foo(Z)],none).
28 | Z = yes.
29 | ==
30 | 
31 | ==
32 | ?- option(foo(yes),[foo(yes)],none).
33 | true.
34 | ==
35 | 
36 | How to make option/3 actually fail (I'm not sure this makes sense)
37 | 
38 | ==
39 | ?- option(foo(yes),[],none).
40 | false.
41 | ==
42 | 
43 | What about this?
44 | 
45 | ==
46 | ?- option(foo(yes),[],yes).
47 | true.
48 | ==
49 | 


--------------------------------------------------------------------------------
/website_comment_texts/partition.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=partition/4
 2 | 
 3 | A partition_freely/4 predicate which partitions into arbitrarily many partitions by accepting a "partitioning closure" as first argument, returning the result as an SWI-Prolog dict where the dict's keys are the partition keys: 
 4 | 
 5 |    - [`partition_freely.pl`](https://github.com/dtonhofer/prolog_notes/blob/master/code/heavycarbon/utils/partition_freely.pl)
 6 |    - [`partition_freely.plt`](https://github.com/dtonhofer/prolog_notes/blob/master/code/heavycarbon/utils/partition_freely.plt)
 7 | 
 8 | Example:
 9 | 
10 | Define a partitioning predicate taking 3 arguments
11 | 
12 | ==
13 | partition_by_length_modulo_m(Modulo,Atom,Key) :-
14 |    atom_length(Atom,Length),
15 |    Key is Length mod Modulo.
16 | ==
17 | 
18 | A "partitioning closure" might then be for exmaple `partition_by_length_modulo_m(5)`: a partially filled in predicate call.
19 | 
20 | Then:
21 | 
22 | ==
23 | ?- partition_freely(
24 |       partition_by_length_modulo_m(5),
25 |       [silent,puffy,left,damaged,fascinated,deafening,
26 |        wistful,whip,nest,inquisitive,imperfect,jog,unwieldy,provide,locket,reign],
27 |       result_tag,
28 |       DictOut).
29 | 
30 | DictOut = result_tag{
31 |    0:[puffy, fascinated, reign],
32 |    1:[silent, inquisitive, locket],
33 |    2:[damaged, wistful, provide],
34 |    3:[jog, unwieldy],
35 |    4:[left, deafening, whip, nest, imperfect]}.
36 | ==
37 | 
38 | 


--------------------------------------------------------------------------------
/website_comment_texts/predicate_semicolon.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=(%3B)/2
 2 | 
 3 | From Covington et al., [Coding Guidelines for Prolog](https://arxiv.org/abs/0911.2899), page 10 and 11: _Decide how to format disjunctions and if-then-elses_
 4 | 
 5 | ```
 6 | All but the simplest disjunctions should be displayed prominently using layouts such as
 7 | 
 8 | (
 9 |    disjunct_1
10 | ;
11 |    disjunct_2
12 | ;
13 |    disjunct_3
14 | )
15 | 
16 | or the more compact
17 | 
18 | ( disjunct_1
19 | ; disjunct_2
20 | ; disjunct_3
21 | )
22 | 
23 | In both styles, parentheses are always present, the closing parenthesis is exactly
24 | below the opening one, and the semicolons stick out in a way that makes misunderstanding much more difficult. 
25 | ```
26 | 
27 | ## A question on Stack Overflow
28 | 
29 | [Is there any difference between using the “or” operator and using several clauses?](https://stackoverflow.com/questions/66224432/is-there-any-difference-between-the-or-operator-and-using-several-predicate)
30 | 
31 | Answer: No, although it depends!
32 | 


--------------------------------------------------------------------------------
/website_comment_texts/random_member.txt:
--------------------------------------------------------------------------------
 1 | ## Doc needs help
 2 | 
 3 | Typo: 
 4 | 
 5 | > Fails of List is the empty list. 
 6 | 
 7 | to
 8 | 
 9 | > Fails if List is the empty list. 
10 | 
11 | ## This needs either a throw or a fix
12 | 
13 | This is not good (well, it it if you want to use random_member/2 to generate a stream of random booleans, but I think that's taking nondeterminism too far):
14 | 
15 | ```
16 | ?- random_member(1,[1,2,3]).
17 | false.
18 | 
19 | ?- random_member(1,[1,2,3]).
20 | true.
21 | ```
22 | 
23 | `random_member(1,[1,2,3])` should succeed because 1 is, if not a "random" member, then at least a member of `[1,2,3]`
24 | 
25 |  
26 | 


--------------------------------------------------------------------------------
/website_comment_texts/read_line_to_string.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/man?predicate=read_line_to_string/2
 2 | 
 3 | ## Example
 4 | 
 5 | Can be used to ask the user as a proper replacement for read/1
 6 | 
 7 | ```
 8 | ask_user :-
 9 |    format("You must answer 'yes' to accept this offer one cannot refuse!~n"),
10 |    read_line_to_string(user_input,S1), 
11 |    string_lower(S1,S2), 
12 |    (
13 |       member(S2,["yes","1","ok","y","ja","oui"])
14 |       -> format("You may proceed, good citizen.~n")
15 |       ;  format("I am sorry to hear that.~n"), fail
16 |    ).   
17 | ```
18 | 
19 | Then:
20 | 
21 | ```
22 | ?- ask_user.
23 | You must answer 'yes' to accept this offer one cannot refuse!
24 | |: yes
25 | You may proceed, good citizen.
26 | true.
27 | ```
28 | 


--------------------------------------------------------------------------------
/website_comment_texts/read_stream_to_codes.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=read_stream_to_codes/3
 2 | 
 3 | "creates a difference-list" implies:
 4 | 
 5 |    - creates an open list `Codes` ending in `Tail` if `Tail` can an unbound variable
 6 |    - creates a closed list if `Tail` is the empty list
 7 |    - prefixes a list `Tail` with the elements read if `Tail` is a (proper or open) list
 8 | 
 9 | ```
10 | attempt(File,Codes,X) :-
11 |     set_prolog_flag(answer_write_options,[max_depth(0)]),
12 |     setup_call_cleanup(
13 |        open(File,read,Stream,[type(text),encoding(utf8)]),
14 |        read_stream_to_codes(Stream,Codes,X),
15 |        (format("Closing",[]),close(Stream))). % N.B: cleanup goal is called only once "call" goal is "done"
16 | ```
17 | 
18 | ```
19 | ?- attempt('small.txt',Codes,X).
20 | Codes = [73,116,39,115,32,115,109,97,108,108,33,10|$VAR(X)].
21 | 
22 | ?- attempt('small.txt',Codes,X),X=[].
23 | Codes = [73,116,39,115,32,115,109,97,108,108,33,10],
24 | X = [].
25 | 
26 | ?- attempt('small.txt',Codes,a).
27 | Codes = [73,116,39,115,32,115,109,97,108,108,33,10|a].
28 | 
29 | ?- attempt('small.txt',Codes,[]).
30 | Codes = [73,116,39,115,32,115,109,97,108,108,33,10].
31 | ```
32 |  
33 | 


--------------------------------------------------------------------------------
/website_comment_texts/run_tests.txt:
--------------------------------------------------------------------------------
 1 | This predicate succeeds if all the tests succeed and fails otherwise (i.e. it is "semi-deterministic")
 2 | 
 3 | Below, the printout has been removed, which can be more or less achieved with 
 4 | 
 5 | ```
 6 | set_test_options([silent(true)])
 7 | ```
 8 | 
 9 | Example:
10 | 
11 | ```
12 | :- begin_tests(fail).
13 |    test("just fail") :- fail.
14 | :- end_tests(fail).
15 | ```
16 | 
17 | Then (removing the printout):
18 | 
19 | ```
20 | ?- run_tests.
21 | false.
22 | ```
23 | 
24 | Another example:
25 | 
26 | ```
27 | :- begin_tests(succeed).
28 |    test("just succeed") :- true.
29 | :- end_tests(succeed).
30 | ```
31 | 
32 | Then (removing the printout):
33 | 
34 | ```
35 | ?- run_tests.
36 | true.
37 | ```
38 | 
39 | Yet another example:
40 | 
41 | ```
42 | :- begin_tests(partially_succeed).
43 |    test("just succeed") :- true.
44 |    test("just fail")    :- fail.
45 | :- end_tests(partially_succeed).
46 | ```
47 | 
48 | Then (removing the printout):
49 | 
50 | ```
51 | ?- run_tests.
52 | false.
53 | ```
54 | 


--------------------------------------------------------------------------------
/website_comment_texts/sleep.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=sleep/1
 2 |  
 3 | ## Example sleeptimes
 4 | 
 5 | Run:
 6 | 
 7 | ==
 8 | bagof([Sleep,Delta]
 9 |    ,T_begin^T_end^(member(Sleep,[-1,0,0.5,1,5]),
10 |      get_time(T_begin),
11 |      sleep(Sleep),
12 |      get_time(T_end),
13 |      Delta is max(0,T_end-T_begin))
14 |    ,Bag).
15 | ==
16 | 
17 | After a few seconds you get something like:
18 | 
19 | ==
20 | Bag = [[-1, 1.9073486328125e-6],
21 |        [0, 5.9604644775390625e-5], 
22 |        [0.5, 0.5000655651092529], 
23 |        [1, 1.0000708103179932],
24 |        [5, 5.000069856643677]].
25 | ==
26 | 
27 | ## Missed opportunity!
28 | 
29 | This is a miss for the use of `is`. One could have done this:
30 | 
31 | ==
32 | ActuallySlept is sleep(WantedSleep).
33 | ==
34 | 
35 | or at least the non-logical predicate:
36 | 
37 | ==
38 | sleep(WantedSleep,ActuallySlept).
39 | ==
40 | 
41 | ## Is sleep interruptible?
42 | 
43 | Documentation says;
44 | 
45 | _On most non-realtime operating systems we can only ensure execution is suspended for at least Time seconds._
46 |  
47 | Compare with Java's [`Thread.sleep()`](https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Thread.html#sleep%28long%29) which sleeps **at least** the specified time, but may be **interrupted early**. It must be interruptible because some other thread could tell your thread you to shut down: https://www.javaspecialists.eu/archive/Issue056.html
48 | 
49 | ==
50 | public void run() {
51 |    while (true) {
52 |       System.out.print(".");
53 |       System.out.flush();
54 |       try {
55 |          Thread.sleep(1000);
56 |       } catch (InterruptedException ex) {
57 |          Thread.currentThread().interrupt(); // very important
58 |          break;
59 |       }
60 |    }
61 |    System.out.println("Shutting down thread");
62 | }
63 | ==
64 | 


--------------------------------------------------------------------------------
/website_comment_texts/string_length.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/doc_for?object=string_length/2
 2 | 
 3 | For "anytext", see [this page](https://eu.swi-prolog.org/pldoc/man?section=string-predicates).
 4 | 
 5 | Also take a look at the comments for atom_length/2.
 6 | 
 7 | ## Replacement
 8 | 
 9 | [Here is simple code](https://github.com/dtonhofer/prolog_code/blob/main/unpacked/onepointfour_basics/doc/README_stringy_length.md) for a common =|stringy_length∕2|= which refers to atom_length/2 and string_length/2 as needed. This already happens, but there is still this troubling naming specificity, which I would like to get rid of.
10 | 
11 | 


--------------------------------------------------------------------------------
/website_comment_texts/sum.pl:
--------------------------------------------------------------------------------
 1 | /*
 2 | dict_sum(Dict,Total) :-
 3 |    (Dict = _{}) -> (Total = 0); aggregate(sum(Val), Key^get_dict(Key,Dict,Val), Total).
 4 | */
 5 | 
 6 | dict_sum(_{} ,0)     :- !.
 7 | dict_sum(Dict,Total) :- aggregate(sum(Val), Key^get_dict(Key,Dict,Val), Total).
 8 | 
 9 | :- begin_tests(sum).
10 | 
11 | test(sum1, [ true(T) ]) :- Dict = quux{},        dict_sum(Dict,Total), T = ( Total == 0 ).
12 | test(sum2, [ true(T) ]) :- Dict = quux{x:1,y:2}, dict_sum(Dict,Total), T = ( Total == 3 ).
13 | 
14 | :- end_tests(sum).
15 | 
16 | rt(_) :- run_tests(sum).
17 | 


--------------------------------------------------------------------------------
/website_comment_texts/sum_list.txt:
--------------------------------------------------------------------------------
 1 | %
 2 | % https://eu.swi-prolog.org/pldoc/doc_for?object=sum_list/2
 3 | %
 4 |  
 5 | As per a remark made on stack overflow, this predicate's name 
 6 | 
 7 |    - expresses what it does "sum the list" 
 8 |    - but does not express the order of its parameters, otherwise it would be called `list_sum/2`.
 9 | 
10 | The predicate exhibits a bruti dataflow :
11 | 
12 | ```
13 | ?- sum_list([1,2,X],6).
14 | ERROR: Arguments are not sufficiently instantiated
15 | ```
16 | 
17 | This is also the same as
18 | 
19 | ```
20 | list_to_sum(L,Sum) :- foldl([X,FL,TR]>>(TR is X+FL),L,0,Sum).
21 | ```
22 | 
23 | There is no `mult_list/2` but one can easily add it:
24 | 
25 | ```
26 | list_to_product(L,Product) :- foldl([X,FL,TR]>>(TR is X*FL),L,1,Product).
27 | ```
28 | 


--------------------------------------------------------------------------------
/website_comment_texts/uuid.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/man?section=uuid
 2 | 
 3 | There is also a pack for UUIDs: https://eu.swi-prolog.org/pack/list?p=pluuid
 4 | 
 5 | Explanation of UUIDs at Wikipedia: https://en.wikipedia.org/wiki/Universally_unique_identifier
 6 | 
 7 |    - UUID Version 1: generated from 60+13 bit timestamp+clocksequence and "node ID" (generally MAC address)
 8 |    - UUID Version 2: generated from an identifier (generally group or user ID), time and node ID (generally MAC address). So-called "DCE security" UUID.
 9 |    - UUID Version 3: deterministic UUID generated by MD5-hashing a "namespace identifier and name" (e.g. an URL)
10 |    - UUID Version 4: generated using a random or pseudo-random number
11 |    - UUID Version 5: deterministic UUID generated by SHA1-hashing a "namespace identifier and name" (e.g. an URL)
12 | 


--------------------------------------------------------------------------------
/website_comment_texts/write_length.txt:
--------------------------------------------------------------------------------
 1 | https://eu.swi-prolog.org/pldoc/man?predicate=write_length/3
 2 | 
 3 | Nonground arguments will give arbitrary length:
 4 | 
 5 | ```
 6 | ?- X=foo(bar(baz(_))),write_length(X,L,[]).
 7 | X = foo(bar(baz(_2500))),
 8 | L = 20.
 9 | 
10 | ?- X=foo(bar(baz(_))),write_length(X,L,[]).
11 | X = foo(bar(baz(_12000))),
12 | L = 21.
13 | ```
14 | 
15 | Note that this does NOT "stringify" codelists or charlists before giving the length, unlike what atom_length/2 or string_length/2 do
16 | 
17 | ```
18 | ?- X=tee,write_length(X,L,[]).
19 | X = tee,
20 | L = 3.
21 | 
22 | ?- X=`tee`,write_length(X,L,[]).
23 | X = [116,101,101],
24 | L = 13.
25 | 
26 | ?- atom_chars(tee,X),write_length(X,L,[]).
27 | X = [t,e,e],
28 | L = 7.
29 | 
30 | ?- X is pi,write_length(X,L,[]).
31 | X = 3.141592653589793,
32 | L = 17.
33 | ```
34 | 
35 | Whereas:
36 | 
37 | ```
38 | ?- X=tee,atom_length(X,L).
39 | X = tee,
40 | L = 3.
41 | 
42 | ?- X=`tee`,atom_length(X,L).
43 | X = [116,101,101],
44 | L = 3.
45 | 
46 | ?- atom_chars(tee,X),atom_length(X,L).
47 | X = [t,e,e],
48 | L = 3.
49 | 
50 | ?- X is pi,atom_length(X,L).
51 | X = 3.141592653589793,
52 | L = 17.
53 | ```
54 | 
55 | 


--------------------------------------------------------------------------------