I'm confused and am handling multiple unexpected systems issues

1 files changed, 0 insertions, 200 deletions

diff --git a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/structure.cpp b/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/structure.cpp
deleted file mode 100644
index b7c8a51..0000000
--- a/intellect-framework-from-internet/starts/meaning-vm/level-2-wip-structs/structure.cpp
+++ /dev/null
@@ -1,200 +0,0 @@
-#include "structure.hpp"
-
-#include "../level-1/helpers.hpp"
-
-using namespace intellect;
-using namespace level1;
-using namespace level2;
-using namespace concepts;
-
-// implement only what is needed now
-
-ref intellect::level2::structure(ref name, std::initializer_list<ref> attributes)
-{
-	ref ret = a(structure, name);
-
-	ref lastfill = nothing;
-
-	// we use [is-linked]->{link-source link-type link-target}
-	// to note the links, because I actually think it might be good to upgrade concepts
-	// themselves to store links this way.  that way actual links are fully referencable.
-	
-	// All that means is making concepts have virtual link access, and checking the type
-	// in a subclass that implements the links.  Just make concepts virtual and implement
-	// link-fetching with one central virtual function.
-
-	// Later we may want a way of mixing in links to any/all concepts.  A handler that gets
-	// called when a specific link type is asked for.
-	// But remember if this handler triggers others it may create infinite recursion.
-	// 		a quick solution was to return too-complex randomly at depth.
-
-	int varnum = 1;
-	for(auto it = attributes.begin(); it != attributes.end();) {
-		auto attrtype = *it++;
-		// add conditions for special attribute types prior to this block and put it in an else
-		{
-			// default: attrtype specifies single raw link type
-			auto attrtarget = *it++;
-			if (attrtarget.isa(fill)) {
-				attrtarget = a(attrtarget);
-				if (lastfill == nothing) {
-					ret.set(first-fill, attrtarget);
-				} else {
-					lastfill.set(next-fill, attrtarget);
-				}
-				lastfill = attrtarget;
-			}
-			ret.link(linked, a(link).link(
-				link-source, topic,
-				link-type, attrtype,
-				link-target, attrtarget
-			));
-		}
-	}
-}
-
-ref intellected::level2::structured(ref structure, std::initializer_list<ref> fills)
-{
-	std::map<ref, ref> values;
-	if (structure.linked(first-fill)) {
-		ref fill = structure.get(first-fill);
-		auto it = fills.begin();
-		while (true) {
-			if (it == fills.end()) { throw std::invalid_argument("missing structure fills"); }
-			values.emplace(fill, *it++);
-			if (!fill.linked(next-fill)) { break; }
-			fill.ptr() = fill.get(next-fill);
-		}
-		if (it != fills.end()) {
-			throw std::invalid_argument("too many structure fills");
-		}
-	}
-
-	ref ret = a(structure);
-	for (ref l : structure.getAll(linked)) {
-		if (l.get(link-source) != topic) { throw std::invalid_argument("TODO nontopic source link"); }
-		ref typ = l.get(link-type);
-		ref targ = l.get(link-target);
-		if (targ.isa(fill)) {
-			ret.link(typ, values[targ]);
-		} else {
-			ret.link(typ, targ);
-		}
-	}
-	return ret;
-}
-
-void intellect::level2::muststructured(ref topic, ref structure)
-{
-	//std::map
-	// umm if a link is listed twice, we want to ensure that it is present twice.
-	// hard. without. link. objects.
-	for (ref l : structure.getAll(linked)) {
-		ref src = l.get(link-source);
-		if (src == concepts::topic) { src.ptr() = topic; }
-
-		ref typ = l.get(link-type);
-		ref targ = l.get(link-target);
-		...fixif ((t).isa(fill)) {
-			ret.link(link-type, values[t]);
-		} else {
-			ret.link(link-type, t);
-		}
-	}
-}
-
-// monologues below: DELETEME unless something crucial inside
-
-// structures
-
-// define promises around structure, in terms of pattern matching
-// if node A is a link-expression, it should match the structure in link-expression.
-// so, link-expression is a structure-promise, maybe
-// 		or we could state that link-expression graph-structured <graph-structure>
-// 		doesn't really matter.
-// link-expression is a group, all members of which have a given graph structure
-// intend for all link-expressions to have same structure
-// group-member-structure
-// 	i'd like to have a bunch of promises or expectations around attributes of the group members
-// these are promises, not expectations.  when broken something is up.
-// group-member-promise
-// 
-// groups: concepts targeted by link-type 'is'
-// groups can-link-by group-member-promise any number of times
-//
-// a group-member-promise can state that the member matches a structure pattern
-//	promise-kind topic-matches-structure
-//	[topic-variable TOPIC]
-//	structure <- propose a structure with some items being variables.
-//	   variables are what is matched against.
-//
-// what about things that can be linked as many times as we want?
-// what about separate restraints on the structure of the variables?
-// what about alternatives?
-//
-// 		it could also make more sense to discuss link attributes of the topic
-// 		has-link, link-type-promise, link-target-promise
-// [!!!!!! ARGH!]
-// - X is linked way1
-// - X may be linked by way2
-// - X is not linked way3
-// - X is linked by either way1, or way2, but not both
-//
-// - relevent topic data:
-// 	[always, sometimes, never] // handles optionals and exclusions
-// 	[is-exactly, is-a] // possibly handles alternatives vs is-a
-//	or: AND, OR, and NOT are very normal ways of doing this.
-//	
-//	what about multipleness?
-//	say there can be as many of a link-type as we want
-//	linked-by [#-times, any-times]
-//		link-type
-//
-//	topic link-type link-target
-//		we will define some special hardcoded link-types to handle further meaning we happen to need.
-//		[always, sometimes, never] can somehow be applied to substatement?
-//		topic color mauve
-//		topic is-a color <- is-a is special, checks parents
-//		
-//		or(topic color mauve, topic color chartreuse) ? how?
-//		topic color (mauve or chartreuse)
-//		topic one-of list(topic color mauve, topic color chartreuse)
-//		topic nothing-but-and-groups
-//		these are roughly expressions
-//		seems like it would kind of work
-//
-//		let's define general structure norms.
-//		it seems it would be nice if a structure were in charge of particular link-types that
-//		are used with its members only in the ways it dictates
-//		so no apple->green->link-type, just confuses everyone
-//
-//		we'll also want a way to instantiate structures quick -> means variables provided
-//		on outer unknown topic things.
-//
-//
-//	here we move around graph reviewal.
-//		for pattern-matching later, we care about the structure of the whole universe, not just
-//		the topic.  we may want to make sure that at least 3 people know the topic, which could
-//		be expressed by saying linked-by 3-times a-person,know,topic.
-//		without pattern searching, this would require reviewing entire database each request.
-//		let's stay topic focused and let a habit expand that to be topic focused if needed
-//			hum then we would need to say that all the 3 people were different
-//			which could be done by linking the group of them to a parts-all-different tag
-//			which would mean referencing the whole result with a variable.
-//				i want to exlore this, but i suppose it is for later.
-//				variable rereference
-//		complex promises need to rereference their parts
-//			the most basic part is saying a topic has a prticular target to a prticular linktype
-//			this type or target could also use a variable, and the variable used as a further topic
-//			we will want some special things, since we don't expand relevent habits yet.
-//
-//	then we care often about link-types
-//	often we have some set link-types
-//	propose alternative link-types are grouped under a link group
-//	so we could say precisely-is vs is-in-group
-//
-// - X may only be linked these ways? <- don't like this, auxiliary data is always helpful
-//
-// this seems way more general
-
-