diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/logical/Logical.java b/reactor/API/src/jetbrains/mps/logic/reactor/logical/Logical.java index b953e42c..ca512719 100644 --- a/reactor/API/src/jetbrains/mps/logic/reactor/logical/Logical.java +++ b/reactor/API/src/jetbrains/mps/logic/reactor/logical/Logical.java @@ -30,6 +30,6 @@ public interface Logical { public boolean isWildcard(); - public LogicalPattern pattern(); + public MetaLogical metaLogical(); } diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/logical/LogicalContext.java b/reactor/API/src/jetbrains/mps/logic/reactor/logical/LogicalContext.java index da106365..892097c3 100644 --- a/reactor/API/src/jetbrains/mps/logic/reactor/logical/LogicalContext.java +++ b/reactor/API/src/jetbrains/mps/logic/reactor/logical/LogicalContext.java @@ -5,6 +5,6 @@ package jetbrains.mps.logic.reactor.logical; public interface LogicalContext { - public Logical variable(LogicalPattern logicalPattern); + public Logical variable(MetaLogical metaLogical); } diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/logical/LogicalPattern.java b/reactor/API/src/jetbrains/mps/logic/reactor/logical/LogicalPattern.java deleted file mode 100644 index faf3af3a..00000000 --- a/reactor/API/src/jetbrains/mps/logic/reactor/logical/LogicalPattern.java +++ /dev/null @@ -1,18 +0,0 @@ -package jetbrains.mps.logic.reactor.logical; - -/*Generated by MPS */ - - -public interface LogicalPattern { - - public String name(); - - public String name(NamingContext namingContext); - - public boolean isWildcard(); - - public Class type(); - - public Logical instance(); - -} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/logical/MetaLogical.java b/reactor/API/src/jetbrains/mps/logic/reactor/logical/MetaLogical.java new file mode 100644 index 00000000..8bb47a64 --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/logical/MetaLogical.java @@ -0,0 +1,37 @@ +package jetbrains.mps.logic.reactor.logical; + +/*Generated by MPS */ + + +public class MetaLogical { + + private static final String WILDCARD = "_"; + + public MetaLogical(String name, Class type) { + this.name = name; + this.type = type; + } + + public MetaLogical(Class type) { + this.name = MetaLogical.WILDCARD + System.identityHashCode(this); + this.type = type; + this.wildcard = true; + } + + public String name() { + return name; + } + + public boolean isWildcard() { + return wildcard; + } + + public Class type() { + return type; + } + + private String name; + private Class type; + private boolean wildcard = false; + +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/logical/MultiLogicalPattern.java b/reactor/API/src/jetbrains/mps/logic/reactor/logical/MultiLogicalPattern.java deleted file mode 100644 index 497e84f3..00000000 --- a/reactor/API/src/jetbrains/mps/logic/reactor/logical/MultiLogicalPattern.java +++ /dev/null @@ -1,14 +0,0 @@ -package jetbrains.mps.logic.reactor.logical; - -/*Generated by MPS */ - - -public interface MultiLogicalPattern extends LogicalPattern { - - public int cardinality(); - - public LogicalPattern patternAt(int idx); - - public LogicalPattern[] toArray(); - -} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/logical/MultiMetaLogical.java b/reactor/API/src/jetbrains/mps/logic/reactor/logical/MultiMetaLogical.java new file mode 100644 index 00000000..c0a255de --- /dev/null +++ b/reactor/API/src/jetbrains/mps/logic/reactor/logical/MultiMetaLogical.java @@ -0,0 +1,37 @@ +package jetbrains.mps.logic.reactor.logical; + +/*Generated by MPS */ + +import java.util.List; +import java.util.ArrayList; + +public class MultiMetaLogical extends MetaLogical { + + public MultiMetaLogical(String name, Class type, int cardinality) { + super(name, type); + this.cardinality = cardinality; + init(); + } + + public int cardinality() { + return cardinality; + } + + public MetaLogical logicalAt(int idx) { + return metaLogicals.get(idx); + } + + public MetaLogical[] toArray() { + MetaLogical[] array = new MetaLogical[cardinality]; + return metaLogicals.toArray(array); + } + + private void init() { + for (int i = 0; i < cardinality; i++) { + metaLogicals.add(new MetaLogical(name() + "_" + (i + 1), type())); + } + } + + private int cardinality; + private List> metaLogicals = new ArrayList>(); +} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/logical/NamingContext.java b/reactor/API/src/jetbrains/mps/logic/reactor/logical/NamingContext.java deleted file mode 100644 index 7460e364..00000000 --- a/reactor/API/src/jetbrains/mps/logic/reactor/logical/NamingContext.java +++ /dev/null @@ -1,41 +0,0 @@ -package jetbrains.mps.logic.reactor.logical; - -/*Generated by MPS */ - -import java.util.Map; -import java.util.HashMap; -import java.util.IdentityHashMap; - -public class NamingContext { - - public String uniqueName(Logical logical) { - return cachedOrMakeUnique(logical, logical.name()); - } - - public String uniqueName(LogicalPattern logical) { - return cachedOrMakeUnique(logical, logical.name()); - } - - private String cachedOrMakeUnique(Object named, String name) { - if (!(cachedUnique.containsKey(named))) { - cachedUnique.put(named, makeUnique(name)); - } - return cachedUnique.get(named); - } - - private String makeUnique(String name) { - int c = getAndIncrementCounter(name); - return (c == 0 ? name : name + c); - } - - private int getAndIncrementCounter(String name) { - Integer c = (uniqueCounters.containsKey(name) ? uniqueCounters.get(name) : 0); - uniqueCounters.put(name, c + 1); - return c; - } - - private Map uniqueCounters = new HashMap(); - - private Map cachedUnique = new IdentityHashMap(); - -} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/logical/trace.info b/reactor/API/src/jetbrains/mps/logic/reactor/logical/trace.info index 43ec22fc..955f6fe3 100644 --- a/reactor/API/src/jetbrains/mps/logic/reactor/logical/trace.info +++ b/reactor/API/src/jetbrains/mps/logic/reactor/logical/trace.info @@ -1,19 +1,22 @@ + - + + + - - - - - - + + + + + + @@ -23,61 +26,13 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + @@ -99,9 +54,9 @@ - - - + + + @@ -115,40 +70,90 @@ - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + - + - + diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/program/ProgramBuilder.java b/reactor/API/src/jetbrains/mps/logic/reactor/program/ProgramBuilder.java deleted file mode 100644 index 4bc287c1..00000000 --- a/reactor/API/src/jetbrains/mps/logic/reactor/program/ProgramBuilder.java +++ /dev/null @@ -1,17 +0,0 @@ -package jetbrains.mps.logic.reactor.program; - -/*Generated by MPS */ - -import jetbrains.mps.logic.reactor.evaluation.SessionSolver; - -public abstract class ProgramBuilder { - - public abstract Program program(String name, SessionSolver sessionSolver); - - public abstract void addRule(Rule rule) throws InvalidRuleException; - - public abstract Constraint constraint(ConstraintSymbol symbol, Object... args); - - public abstract Predicate predicate(PredicateSymbol symbol, Object... args); - -} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/program/RuleBuilder.java b/reactor/API/src/jetbrains/mps/logic/reactor/program/RuleBuilder.java deleted file mode 100644 index 3cb8bb4b..00000000 --- a/reactor/API/src/jetbrains/mps/logic/reactor/program/RuleBuilder.java +++ /dev/null @@ -1,154 +0,0 @@ -package jetbrains.mps.logic.reactor.program; - -/*Generated by MPS */ - -import java.util.Collections; -import com.google.common.collect.Iterables; -import java.util.List; -import java.util.ArrayList; - -public class RuleBuilder { - - public RuleBuilder(String tag) { - this.tag = tag; - } - - public RuleBuilder appendBody(AndItem... item) { - for (int i = 0; i < item.length; i++) { - body.add(item[i]); - } - return this; - } - - public RuleBuilder appendGuard(Predicate... pred) { - for (int i = 0; i < pred.length; i++) { - guard.add(pred[i]); - } - return this; - } - - public RuleBuilder appendHeadReplaced(Constraint... cst) { - for (int i = 0; i < cst.length; i++) { - headReplaced.add(cst[i]); - } - return this; - } - - public RuleBuilder appendHeadKept(Constraint... cst) { - for (int i = 0; i < cst.length; i++) { - headKept.add(cst[i]); - } - return this; - } - - public boolean hasHead() { - return !((headKept.isEmpty() && headReplaced.isEmpty())); - } - - public boolean hasGuard() { - return !(guard.isEmpty()); - } - - public boolean hasBody() { - return !(body.isEmpty()); - } - - public RuleBuilder merge(RuleBuilder... other) { - doMerge(other); - return this; - } - - public jetbrains.mps.logic.reactor.program.Rule toRule() throws InvalidRuleException { - jetbrains.mps.logic.reactor.program.Rule.Kind kind; - if (!(headKept.isEmpty()) && !(headReplaced.isEmpty())) { - kind = jetbrains.mps.logic.reactor.program.Rule.Kind.SIMPAGATION; - - } else if (!(headReplaced.isEmpty())) { - kind = jetbrains.mps.logic.reactor.program.Rule.Kind.SIMPLIFICATION; - - } else if (!(headKept.isEmpty())) { - kind = jetbrains.mps.logic.reactor.program.Rule.Kind.PROPAGATION; - - } else { - throw new InvalidRuleException("Invalid rule: empty head in " + toString()); - } - - if (body.isEmpty()) { - throw new InvalidRuleException("Invalid rule: empty body in " + toString()); - } - - headKept = Collections.unmodifiableList(headKept); - headReplaced = Collections.unmodifiableList(headReplaced); - guard = Collections.unmodifiableList(guard); - body = Collections.unmodifiableList(body); - - return new RuleBuilder.Rule(kind, tag); - } - - @Override - public String toString() { - return String.format("%s (%d,%d,%d,%d)", tag, headKept.size(), headReplaced.size(), guard.size(), body.size()); - } - - private void doMerge(RuleBuilder... other) { - for (int i = 0; i < other.length; i++) { - RuleBuilder toMerge = other[i]; - - headReplaced.addAll(toMerge.headReplaced); - headKept.addAll(toMerge.headKept); - guard.addAll(toMerge.guard); - body.addAll(toMerge.body); - } - } - - public class Rule extends jetbrains.mps.logic.reactor.program.Rule { - - private Rule(jetbrains.mps.logic.reactor.program.Rule.Kind kind, String tag) { - this.kind = kind; - this.tag = tag; - } - - public jetbrains.mps.logic.reactor.program.Rule.Kind kind() { - return kind; - } - - @Override - public String tag() { - return tag; - } - - @Override - public Iterable headKept() { - return headKept; - } - - @Override - public Iterable headReplaced() { - return headReplaced; - } - - @Override - public Iterable guard() { - return guard; - } - - @Override - public Iterable body() { - return body; - } - - @Override - public Iterable all() { - return Iterables.concat(headKept, headReplaced, guard, body); - } - - private jetbrains.mps.logic.reactor.program.Rule.Kind kind; - private String tag; - } - - private String tag; - private List headKept = new ArrayList(4); - private List headReplaced = new ArrayList(4); - private List guard = new ArrayList(4); - private List body = new ArrayList(4); -} diff --git a/reactor/API/src/jetbrains/mps/logic/reactor/program/trace.info b/reactor/API/src/jetbrains/mps/logic/reactor/program/trace.info index c9e3e0db..bd62ab5b 100644 --- a/reactor/API/src/jetbrains/mps/logic/reactor/program/trace.info +++ b/reactor/API/src/jetbrains/mps/logic/reactor/program/trace.info @@ -1,10 +1,8 @@ - - @@ -13,15 +11,14 @@ - - - - - - - + + + + + + @@ -37,38 +34,14 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + @@ -82,33 +55,33 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -137,10 +110,10 @@ - - - - + + + + @@ -153,8 +126,8 @@ - - + + @@ -162,13 +135,13 @@ - - - - - - - + + + + + + + @@ -178,9 +151,9 @@ - - - + + + @@ -191,8 +164,8 @@ - - + + @@ -202,13 +175,13 @@ - - - - - - - + + + + + + + @@ -220,186 +193,12 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + @@ -414,10 +213,10 @@ - - - - + + + + diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/Handler.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/Handler.kt index c4caa28b..66ef4ac0 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/Handler.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/Handler.kt @@ -6,7 +6,7 @@ import jetbrains.mps.logic.reactor.evaluation.PredicateInvocation import jetbrains.mps.logic.reactor.evaluation.SessionSolver import jetbrains.mps.logic.reactor.logical.Logical import jetbrains.mps.logic.reactor.logical.LogicalContext -import jetbrains.mps.logic.reactor.logical.LogicalPattern +import jetbrains.mps.logic.reactor.logical.MetaLogical import jetbrains.mps.logic.reactor.program.* import java.util.* @@ -159,7 +159,7 @@ class Handler : Matcher.AuxOccurrences { } private val noLogicalContext: LogicalContext = object: LogicalContext { - override fun variable(logicalPattern: LogicalPattern): Logical = TODO() + override fun variable(metaLogical: MetaLogical): Logical = TODO() } private fun Predicate.invocation(logicalContext: LogicalContext): PredicateInvocation = object: PredicateInvocation { diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/Logical.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/Logical.kt index 989070a0..3ad85443 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/Logical.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/Logical.kt @@ -2,8 +2,7 @@ package jetbrains.mps.logic.reactor.core import jetbrains.mps.logic.reactor.logical.Logical -import jetbrains.mps.logic.reactor.logical.LogicalPattern -import jetbrains.mps.logic.reactor.logical.NamingContext +import jetbrains.mps.logic.reactor.logical.MetaLogical import jetbrains.mps.logic.reactor.logical.SolverLogical import java.util.* @@ -29,9 +28,9 @@ fun Logical<*>.removeObserver(observer: LogicalObserver) { (this as MemLogical<*>).parentObservers.removeAll { p -> p.second == observer } } -fun LogicalPattern.logical(): Logical = MemLogical(name()) +fun MetaLogical.logical(): Logical = MemLogical(this) -fun LogicalPattern.logical(value: V): Logical = MemLogical(name(), value) +fun MetaLogical.logical(value: V): Logical = MemLogical(name(), value) class MemLogical : SolverLogical { @@ -41,7 +40,7 @@ class MemLogical : SolverLogical { val name: String - val pattern: LogicalPattern + val metaLogical: MetaLogical var _parent: MemLogical? = null @@ -55,24 +54,24 @@ class MemLogical : SolverLogical { constructor(value: T) { this.name = "$${++lastIdx}" - this.pattern = DefaultLogicalPattern(name) + this.metaLogical = DefaultMetaLogical(name) this._value = value } constructor(name: String) { this.name = "${name}_${++lastIdx}" - this.pattern = DefaultLogicalPattern(name) + this.metaLogical = DefaultMetaLogical(name) } constructor(name: String, value: T) { this.name = "${name}_${++lastIdx}" - this.pattern = DefaultLogicalPattern(name) + this.metaLogical = DefaultMetaLogical(name) this._value = value } - constructor(pattern: LogicalPattern) { - this.pattern = pattern - this.name = "${pattern.name()}_${++lastIdx}" + constructor(metaLogical: MetaLogical) { + this.metaLogical = metaLogical + this.name = "${metaLogical.name()}_${++lastIdx}" } override fun name(): String = name @@ -83,7 +82,7 @@ class MemLogical : SolverLogical { override fun isWildcard(): Boolean = TODO() - override fun pattern(): LogicalPattern = pattern + override fun metaLogical(): MetaLogical = metaLogical override fun findRoot(): SolverLogical = find() @@ -187,16 +186,12 @@ class MemLogical : SolverLogical { } -data class DefaultLogicalPattern (val name: String) : LogicalPattern { +class DefaultMetaLogical (val name: String) : MetaLogical(name, Object::class.java as Class) { override fun name(): String? { throw UnsupportedOperationException() } - override fun name(namingContext: NamingContext?): String? { - throw UnsupportedOperationException() - } - override fun isWildcard(): Boolean { throw UnsupportedOperationException() } @@ -205,7 +200,4 @@ data class DefaultLogicalPattern (val name: String) : LogicalPattern { throw UnsupportedOperationException() } - override fun instance(): Logical? { - throw UnsupportedOperationException() - } } \ No newline at end of file diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/Matcher.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/Matcher.kt index 5f2cff08..3b91395b 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/Matcher.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/Matcher.kt @@ -4,7 +4,7 @@ import jetbrains.mps.logic.reactor.evaluation.ConstraintOccurrence import jetbrains.mps.logic.reactor.evaluation.MatchRule import jetbrains.mps.logic.reactor.logical.Logical import jetbrains.mps.logic.reactor.logical.LogicalContext -import jetbrains.mps.logic.reactor.logical.LogicalPattern +import jetbrains.mps.logic.reactor.logical.MetaLogical import jetbrains.mps.logic.reactor.program.Constraint import jetbrains.mps.logic.reactor.program.ConstraintSymbol import jetbrains.mps.logic.reactor.program.Rule @@ -78,11 +78,11 @@ class RuleTerm(rule: Rule) : Function(rule.tag(), (rule.headKept() + rule.headReplaced()).map { c -> ConstraintTerm(c) }) {} /** Function term with arguments == constraint arguments converted to terms. - * LogicalPattern arguments are term variables. + * MetaLogical arguments are term variables. * Everything else is either a term or a constant wrapping the value. */ class ConstraintTerm(constraint: Constraint) : Function(constraint.symbol(), - constraint.arguments().map { arg -> if (arg is LogicalPattern<*>) Variable(arg) else asTerm(arg) }) {} + constraint.arguments().map { arg -> if (arg is MetaLogical<*>) Variable(arg) else asTerm(arg) }) {} /** Function term with arguments == terms corresponding to constraint occurrences. Never contains variables. */ class PartialMatchTerm(pm : PartialMatch) : diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/OccurrenceStore.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/OccurrenceStore.kt index 7dc348c3..19795ee4 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/OccurrenceStore.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/OccurrenceStore.kt @@ -4,7 +4,6 @@ import com.github.andrewoma.dexx.collection.ConsList import jetbrains.mps.logic.reactor.evaluation.ConstraintOccurrence import jetbrains.mps.logic.reactor.logical.Logical import jetbrains.mps.logic.reactor.logical.LogicalContext -import jetbrains.mps.logic.reactor.logical.LogicalPattern import jetbrains.mps.logic.reactor.program.Constraint import jetbrains.mps.logic.reactor.program.ConstraintSymbol import java.util.* diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/PartialMatch.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/PartialMatch.kt index b0a3479c..eaa68a56 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/PartialMatch.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/PartialMatch.kt @@ -7,7 +7,7 @@ import jetbrains.mps.logic.reactor.evaluation.ConstraintOccurrence import jetbrains.mps.logic.reactor.evaluation.MatchRule import jetbrains.mps.logic.reactor.logical.Logical import jetbrains.mps.logic.reactor.logical.LogicalContext -import jetbrains.mps.logic.reactor.logical.LogicalPattern +import jetbrains.mps.logic.reactor.logical.MetaLogical import jetbrains.mps.logic.reactor.program.Constraint import jetbrains.mps.logic.reactor.program.Rule import jetbrains.mps.unification.Unification @@ -23,7 +23,7 @@ class PartialMatch(val rule: Rule, val profiler: Profiler? = null) : MatchRule { private set var discarded = emptyConsList>() private set - var pattern2logical = Maps.of, PersSet>>() + var meta2logical = Maps.of, PersSet>>() private set private lateinit var logicalContext : LogicalContext @@ -35,12 +35,12 @@ class PartialMatch(val rule: Rule, val profiler: Profiler? = null) : MatchRule { this.kept = if (keep != null) original.kept.prepend(keep) else original.kept this.discarded = if (discard != null) original.discarded.prepend(discard) else original.discarded - this.pattern2logical = original.pattern2logical + this.meta2logical = original.meta2logical val pair = keep ?: discard!! for ((ptr, log) in pair.first.arguments().zip(pair.second.arguments())) { - if (ptr is LogicalPattern<*> && log is Logical<*>) { - val logSet = pattern2logical.get(ptr) - this.pattern2logical = pattern2logical.put(ptr, logSet?.add(log.findRoot()) ?: Sets.of(log.findRoot())) + if (ptr is MetaLogical<*> && log is Logical<*>) { + val logSet = meta2logical.get(ptr) + this.meta2logical = meta2logical.put(ptr, logSet?.add(log.findRoot()) ?: Sets.of(log.findRoot())) } } } @@ -72,8 +72,8 @@ class PartialMatch(val rule: Rule, val profiler: Profiler? = null) : MatchRule { val values = HashSet() for (arg in cst.arguments()) { - if (arg is LogicalPattern<*>) - pattern2logical.get(arg)?.let { logSet -> logicals.addAll(logSet) } + if (arg is MetaLogical<*>) + meta2logical.get(arg)?.let { logSet -> logicals.addAll(logSet) } else values.add(arg!!) } @@ -120,7 +120,7 @@ class PartialMatch(val rule: Rule, val profiler: Profiler? = null) : MatchRule { return false } - // variables come from LogicalPattern instances in rules + // variables come from MetaLogical instances in rules // any successful binding results in either new Logical with associated value, // or a new value for a Logical already existing in this context @@ -128,24 +128,24 @@ class PartialMatch(val rule: Rule, val profiler: Profiler? = null) : MatchRule { // thus triangular form never has variables on the right hand side this.logicalContext = object: LogicalContext { - // invariant: the variables in substitution bindings can only be instances of LogicalPattern - val ptr2val: MutableMap, Any?> = HashMap(subst.bindings().map { b -> - (b.`var`().symbol() as LogicalPattern).to(b.term().toValue()) + // invariant: the variables in substitution bindings can only be instances of MetaLogical + val ptr2val: MutableMap, Any?> = HashMap(subst.bindings().map { b -> + (b.`var`().symbol() as MetaLogical).to(b.term().toValue()) }.toMap()) - val ptr2log: MutableMap, Logical<*>> = HashMap() + val ptr2log: MutableMap, Logical<*>> = HashMap() - override fun variable(logicalPattern: LogicalPattern): Logical { - if (!ptr2log.containsKey(logicalPattern)) { - if (ptr2val.containsKey(logicalPattern)) { - val value = ptr2val[logicalPattern] - ptr2log[logicalPattern] = if (value is Logical<*>) value else MemLogical(value) + override fun variable(metaLogical: MetaLogical): Logical { + if (!ptr2log.containsKey(metaLogical)) { + if (ptr2val.containsKey(metaLogical)) { + val value = ptr2val[metaLogical] + ptr2log[metaLogical] = if (value is Logical<*>) value else MemLogical(value) } else { - ptr2log[logicalPattern] = logicalPattern.logical() + ptr2log[metaLogical] = metaLogical.logical() } } - return ptr2log[logicalPattern] as Logical + return ptr2log[metaLogical] as Logical } } return true diff --git a/reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleIndex.kt b/reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleIndex.kt index 8e7f6ddb..40c37797 100644 --- a/reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleIndex.kt +++ b/reactor/Core/src/jetbrains/mps/logic/reactor/core/RuleIndex.kt @@ -1,7 +1,6 @@ package jetbrains.mps.logic.reactor.core import jetbrains.mps.logic.reactor.evaluation.ConstraintOccurrence -import jetbrains.mps.logic.reactor.logical.LogicalPattern import jetbrains.mps.logic.reactor.program.Constraint import jetbrains.mps.logic.reactor.program.ConstraintSymbol import jetbrains.mps.logic.reactor.program.Rule diff --git a/reactor/Test/src/program/MemConstraint.kt b/reactor/Test/src/program/MemConstraint.kt index 6fe1b264..94b3ad08 100644 --- a/reactor/Test/src/program/MemConstraint.kt +++ b/reactor/Test/src/program/MemConstraint.kt @@ -2,7 +2,7 @@ package program import jetbrains.mps.logic.reactor.evaluation.ConstraintOccurrence import jetbrains.mps.logic.reactor.logical.LogicalContext -import jetbrains.mps.logic.reactor.logical.LogicalPattern +import jetbrains.mps.logic.reactor.logical.MetaLogical import jetbrains.mps.logic.reactor.program.Constraint import jetbrains.mps.logic.reactor.program.ConstraintSymbol import java.util.* @@ -18,7 +18,7 @@ data class MemConstraint(val symbol: ConstraintSymbol, val arguments: List) override fun arguments(): List = arguments override fun occurrenceArguments(logicalContext: LogicalContext): Collection<*> = arguments.map { a -> - if (a is LogicalPattern<*>) logicalContext.variable(a) + if (a is MetaLogical<*>) logicalContext.variable(a) else a } diff --git a/reactor/Test/src/program/MemLogicalPattern.kt b/reactor/Test/src/program/MemLogicalPattern.kt deleted file mode 100644 index 85c61088..00000000 --- a/reactor/Test/src/program/MemLogicalPattern.kt +++ /dev/null @@ -1,28 +0,0 @@ -package program - -import jetbrains.mps.logic.reactor.logical.Logical -import jetbrains.mps.logic.reactor.logical.LogicalPattern -import jetbrains.mps.logic.reactor.logical.NamingContext - -/** - * @author Fedor Isakov - */ - -data class MemLogicalPattern(val name: String, val type: Class, val wildcard: Boolean) : LogicalPattern { - - constructor(name: String, type: Class) : this(name, type, false) {} - - override fun name(): String = name - - override fun name(namingContext: NamingContext): String = TODO() - - override fun isWildcard(): Boolean = wildcard - - override fun type(): Class = type - - override fun instance(): Logical { - // FIXME wrong - throw UnsupportedOperationException("fixme") - } - -} \ No newline at end of file diff --git a/reactor/Test/src/program/MemProgram.kt b/reactor/Test/src/program/MemProgram.kt index 87bda9e8..2e7ae839 100644 --- a/reactor/Test/src/program/MemProgram.kt +++ b/reactor/Test/src/program/MemProgram.kt @@ -9,25 +9,70 @@ import program.MemConstraint import java.util.* import java.util.Collections.* -class MemProgramBuilder(val sessionSolver: SessionSolver) : ProgramBuilder() { +class MemProgramBuilder(val sessionSolver: SessionSolver) { private val rules = ArrayList() private val registry = ConstraintRegistry(sessionSolver) - override fun program(name: String, sessionSolver: SessionSolver): Program = MemProgram(name, ArrayList(rules), sessionSolver, registry) + fun program(name: String, sessionSolver: SessionSolver): Program = MemProgram(name, ArrayList(rules), sessionSolver, registry) - override fun addRule(rule: Rule) { + fun addRule(rule: Rule) { registry.update(rule) rules.add(rule) } - override fun constraint(symbol: ConstraintSymbol, vararg args: Any): Constraint = MemConstraint(symbol, listOf(* args)) + fun constraint(symbol: ConstraintSymbol, vararg args: Any): Constraint = MemConstraint(symbol, listOf(* args)) - override fun predicate(symbol: PredicateSymbol, vararg args: Any?): Predicate = TODO() + fun predicate(symbol: PredicateSymbol, vararg args: Any?): Predicate = TODO() } +open class RuleBuilder(val tag: String) { + val kept = ArrayList() + val replaced = ArrayList() + val guard = ArrayList() + val body = ArrayList() + + fun appendHeadKept(vararg cst: Constraint) { + kept.addAll(cst) + } + fun appendHeadReplaced(vararg cst: Constraint) { + replaced.addAll(cst) + } + fun appendGuard(vararg prd: Predicate) { + guard.addAll(prd) + } + fun appendBody(vararg andItem: AndItem) { + body.addAll(andItem) + } + fun toRule(): Rule = MemRule(tag, kept, replaced, guard, body) +} + +class MemRule( + val tag: String, + val kept: Collection, + val replaced: Collection, + val guard: Collection, + val body: Collection) : Rule() { + + override fun kind(): Kind = TODO() + + override fun tag(): String = tag + + override fun headKept(): Iterable = kept + + override fun headReplaced(): Iterable = replaced + + override fun guard(): Iterable = guard + + override fun body(): Iterable = body + + override fun all(): Iterable = + if (body.isEmpty()) throw InvalidRuleException("no body") + else (kept + replaced).map { it as AndItem } + guard + body +} + class MemProgram(val name: String, val myRules : List, val sessionSolver: SessionSolver, val registry: ConstraintRegistry) : Program() { override fun name(): String = name diff --git a/reactor/Test/test/JavaExpressionHelper.kt b/reactor/Test/test/JavaExpressionHelper.kt index ce7d2784..3909f153 100644 --- a/reactor/Test/test/JavaExpressionHelper.kt +++ b/reactor/Test/test/JavaExpressionHelper.kt @@ -2,7 +2,7 @@ import jetbrains.mps.logic.reactor.evaluation.PredicateInvocation import jetbrains.mps.logic.reactor.evaluation.Queryable import jetbrains.mps.logic.reactor.logical.Logical import jetbrains.mps.logic.reactor.logical.LogicalContext -import jetbrains.mps.logic.reactor.logical.LogicalPattern +import jetbrains.mps.logic.reactor.logical.MetaLogical import jetbrains.mps.logic.reactor.program.* import java.util.* @@ -15,20 +15,20 @@ fun expression(body: () -> Boolean): ConjBuilder.() -> Unit = { add(JavaPredicateSymbol(1).withCode(body)) } -fun , LPX: LogicalPattern> +fun , LPX: MetaLogical> expression(body: (LX) -> Boolean, x: LPX): ConjBuilder.() -> Unit = { add(JavaPredicateSymbol(2).withCode(body, x)) } -fun , LPX: LogicalPattern, - Y, LY: Logical, LPY: LogicalPattern> +fun , LPX: MetaLogical, + Y, LY: Logical, LPY: MetaLogical> expression(body: (LX, LY) -> Boolean, x: LPX, y: LPY): ConjBuilder.() -> Unit = { add(JavaPredicateSymbol(3).withCode(body, x, y)) } -fun , LPX: LogicalPattern, - Y, LY: Logical, LPY: LogicalPattern, - Z, LZ: Logical, LPZ: LogicalPattern> +fun , LPX: MetaLogical, + Y, LY: Logical, LPY: MetaLogical, + Z, LZ: Logical, LPZ: MetaLogical> expression(body: (LX, LY, LZ) -> Boolean, x: LPX, y: LPY, z: LPZ): ConjBuilder.() -> Unit = { add(JavaPredicateSymbol(4).withCode(body, x, y, z)) } @@ -37,21 +37,21 @@ fun statement(body: () -> Unit): ConjBuilder.() -> Unit = { add(JavaPredicateSymbol(1).withCode { body.invoke(); true }) } -fun > +fun > statement( body: (Logical) -> Unit, x: LPX): ConjBuilder.() -> Unit = { add(JavaPredicateSymbol(2).withCode({ x -> body.invoke(x); true }, x)) } -fun , - Y, LPY: LogicalPattern> +fun , + Y, LPY: MetaLogical> statement(body: (Logical, Logical) -> Unit, x: LPX, y: LPY): ConjBuilder.() -> Unit = { add(JavaPredicateSymbol(3).withCode({ x, y -> body.invoke(x, y); true }, x, y)) } -fun , - Y, LPY: LogicalPattern, - Z, LPZ: LogicalPattern> +fun , + Y, LPY: MetaLogical, + Z, LPZ: MetaLogical> statement(body: (Logical, Logical, Logical) -> Unit, x: LPX, y: LPY, z: LPZ): ConjBuilder.() -> Unit = { add(JavaPredicateSymbol(4).withCode({ x, y, z -> body.invoke(x, y, z); true }, x, y, z)) } @@ -98,7 +98,7 @@ data class TestJavaPredicate(val symbol: JavaPredicateSymbol, val expr: JavaExpr override fun symbol(): PredicateSymbol = symbol override fun invocationArguments(logicalContext: LogicalContext): Collection<*> = args.map { a -> - if (a is LogicalPattern<*>) logicalContext.variable(a) + if (a is MetaLogical<*>) logicalContext.variable(a) else a } } @@ -108,18 +108,18 @@ data class TestJavaPredicate(val symbol: JavaPredicateSymbol, val expr: JavaExpr private fun JavaPredicateSymbol.withCode(code: () -> Boolean) = TestJavaPredicate(this, JavaExpression0(code), listOf(System.identityHashCode(code))) -private fun , LPX: LogicalPattern> +private fun , LPX: MetaLogical> JavaPredicateSymbol.withCode(code: (LX) -> Boolean, x: LPX) = TestJavaPredicate(this, JavaExpression1(code), listOf(System.identityHashCode(code), x)) -private fun , LPX: LogicalPattern, - Y, LY: Logical, LPY: LogicalPattern> +private fun , LPX: MetaLogical, + Y, LY: Logical, LPY: MetaLogical> JavaPredicateSymbol.withCode(code: (LX, LY) -> Boolean, x: LPX, y: LPY) = TestJavaPredicate(this, JavaExpression2(code), listOf(System.identityHashCode(code), x, y)) -private fun , LPX: LogicalPattern, - Y, LY: Logical, LPY: LogicalPattern, - Z, LZ: Logical, LPZ: LogicalPattern> +private fun , LPX: MetaLogical, + Y, LY: Logical, LPY: MetaLogical, + Z, LZ: Logical, LPZ: MetaLogical> JavaPredicateSymbol.withCode(code: (LX, LY, LZ) -> Boolean, x: LPX, y: LPY, z: LPZ) = TestJavaPredicate(this, JavaExpression3(code), listOf(System.identityHashCode(code), x, y, z)) diff --git a/reactor/Test/test/LogicalHelper.kt b/reactor/Test/test/LogicalHelper.kt index 12d458d8..28732a84 100644 --- a/reactor/Test/test/LogicalHelper.kt +++ b/reactor/Test/test/LogicalHelper.kt @@ -4,7 +4,6 @@ import jetbrains.mps.logic.reactor.evaluation.PredicateInvocation import jetbrains.mps.logic.reactor.logical.* import jetbrains.mps.logic.reactor.program.Predicate import jetbrains.mps.logic.reactor.program.PredicateSymbol -import program.MemLogicalPattern import java.util.* /** @@ -21,16 +20,16 @@ fun logical(name1: String, name2: String) = Pair(MemLogical(name1), fun logical(name1: String, name2: String, name3: String) = Triple(MemLogical(name1), MemLogical(name2), MemLogical(name3)) -inline fun logicalPattern(name: String) = MemLogicalPattern(name, T::class.java) +inline fun metaLogical(name: String) = MetaLogical(name, T::class.java) -inline fun logicalPattern(name1: String, name2: String) = - Pair(MemLogicalPattern(name1, T::class.java), MemLogicalPattern(name2, T::class.java)) +inline fun metaLogical(name1: String, name2: String) = + Pair(MetaLogical(name1, T::class.java), MetaLogical(name2, T::class.java)) -inline fun logicalPattern(name1: String, name2: String, name3: String) = +inline fun metaLogical(name1: String, name2: String, name3: String) = Triple( - MemLogicalPattern(name1, T::class.java), - MemLogicalPattern(name2, T::class.java), - MemLogicalPattern(name3, T::class.java)) + MetaLogical(name1, T::class.java), + MetaLogical(name2, T::class.java), + MetaLogical(name3, T::class.java)) fun Logical.get(): T = findRoot().value() @@ -71,7 +70,7 @@ data class TestEqPredicate(val left: Any, val right: Any) : Predicate { override fun symbol(): PredicateSymbol = PredicateSymbol("equals", 2) override fun invocationArguments(logicalContext: LogicalContext): Collection<*> = listOf(left, right).map { a -> - if (a is LogicalPattern<*>) logicalContext.variable(a) + if (a is MetaLogical<*>) logicalContext.variable(a) else a } diff --git a/reactor/Test/test/RulesHelper.kt b/reactor/Test/test/RulesHelper.kt index 49bceb14..5c53fc06 100644 --- a/reactor/Test/test/RulesHelper.kt +++ b/reactor/Test/test/RulesHelper.kt @@ -1,6 +1,5 @@ import jetbrains.mps.logic.reactor.evaluation.ConstraintOccurrence import jetbrains.mps.logic.reactor.logical.LogicalContext -import jetbrains.mps.logic.reactor.logical.LogicalPattern import jetbrains.mps.logic.reactor.program.* import program.MemConstraint import TestConstraintOccurrence @@ -15,7 +14,7 @@ import java.util.* class Builder(val env: Environment, val rules: List) { } -class Environment(val programBuilder: ProgramBuilder? = null) { +class Environment(val programBuilder: MemProgramBuilder? = null) { val equalsSolver = EqualsSolver() val expressionSolver = ExpressionSolver() } @@ -24,7 +23,7 @@ fun program(vararg ruleBuilders : Environment.() -> Rule): Builder { return builder(Environment(), ruleBuilders) } -fun program(pb: ProgramBuilder, vararg ruleBuilders : Environment.() -> Rule): Builder { +fun program(pb: MemProgramBuilder, vararg ruleBuilders : Environment.() -> Rule): Builder { return builder(Environment(pb), ruleBuilders) } diff --git a/reactor/Test/test/TestHandler.kt b/reactor/Test/test/TestHandler.kt index 33ccd4c4..cc4d0657 100644 --- a/reactor/Test/test/TestHandler.kt +++ b/reactor/Test/test/TestHandler.kt @@ -3,7 +3,6 @@ import jetbrains.mps.logic.reactor.evaluation.ConstraintOccurrence import jetbrains.mps.logic.reactor.evaluation.Queryable import jetbrains.mps.logic.reactor.evaluation.SessionSolver import jetbrains.mps.logic.reactor.logical.Logical -import jetbrains.mps.logic.reactor.logical.LogicalPattern import solver.MemSessionSolver import jetbrains.mps.logic.reactor.program.ConstraintSymbol import jetbrains.mps.logic.reactor.program.JavaPredicateSymbol @@ -207,8 +206,8 @@ class TestHandler { } @Test - fun basicLogicalPattern() { - val (X, Y) = logicalPattern("X", "Y") + fun basicMetaLogical() { + val (X, Y) = metaLogical("X", "Y") program( rule("rule1", headReplaced( @@ -285,7 +284,7 @@ class TestHandler { @Test fun occurrenceReactivated() { - val X = logicalPattern("X") + val X = metaLogical("X") program( rule("zeroth", headKept( constraint("foo") ), body( statement({ x -> x.set(999) }, X), @@ -327,7 +326,7 @@ class TestHandler { @Test fun occurrenceReactivatedAfterUnion() { - val (X, Y) = logicalPattern("X", "Y") + val (X, Y) = metaLogical("X", "Y") var handler : Handler? = null program( rule("first", @@ -368,7 +367,7 @@ class TestHandler { @Test fun occurrenceReactivatedAfterUnionUnbound() { - val (X, Y) = logicalPattern("X", "Y") + val (X, Y) = metaLogical("X", "Y") var handler : Handler? = null program( rule("first", diff --git a/reactor/Test/test/TestMatcher.kt b/reactor/Test/test/TestMatcher.kt index e29a091c..f88bb875 100644 --- a/reactor/Test/test/TestMatcher.kt +++ b/reactor/Test/test/TestMatcher.kt @@ -3,7 +3,6 @@ import jetbrains.mps.logic.reactor.core.logical import jetbrains.mps.logic.reactor.core.matches import jetbrains.mps.logic.reactor.evaluation.ConstraintOccurrence import jetbrains.mps.logic.reactor.logical.Logical -import jetbrains.mps.logic.reactor.logical.LogicalPattern import jetbrains.mps.logic.reactor.program.Constraint import jetbrains.mps.logic.reactor.program.ConstraintSymbol import org.junit.Assert.* @@ -188,8 +187,8 @@ class TestMatcher { } @Test - fun logicalPattern() { - val (A, B, C) = logicalPattern("A", "B", "C") + fun metaLogical() { + val (A, B, C) = metaLogical("A", "B", "C") val b = B.logical() program( @@ -204,14 +203,14 @@ class TestMatcher { ).matcher().lookupMatches(occurrence("foo", "blah", b)).first().run { assertEquals("blah", logicalContext().variable(A).findRoot().value()) assertSame(b, logicalContext().variable(B)) - assertEquals(C.logical().pattern(), logicalContext().variable(C).pattern()) + assertEquals(C.logical().metaLogical(), logicalContext().variable(C).metaLogical()) } } @Test - fun matchLogicalPattern() { - val (M, N) = logicalPattern("M", "N") + fun matchMetaLogical() { + val (M, N) = metaLogical("M", "N") program( rule("main1", diff --git a/reactor/Test/test/TestProgram.kt b/reactor/Test/test/TestProgram.kt index 8f232ee0..2ba65b7c 100644 --- a/reactor/Test/test/TestProgram.kt +++ b/reactor/Test/test/TestProgram.kt @@ -59,7 +59,7 @@ class TestProgram { @Test fun logicalValue() { - val (X, Y, Z) = logicalPattern("X", "Y", "Z") + val (X, Y, Z) = metaLogical("X", "Y", "Z") program( rule("main", headReplaced( @@ -89,7 +89,7 @@ class TestProgram { @Test fun simpleProgram() { - val (X, Y) = logicalPattern("X", "Y") + val (X, Y) = metaLogical("X", "Y") program( rule("main", @@ -113,7 +113,7 @@ class TestProgram { @Test fun gcd() { - val (M, N, TMP) = logicalPattern("M", "N", "TMP") + val (M, N, TMP) = metaLogical("M", "N", "TMP") program( rule("main", headReplaced( constraint("main") ), body( statement({ m, n -> m.set(21); n.set(35) }, M, N), @@ -142,7 +142,7 @@ class TestProgram { @Test fun primes() { - val (M, N) = logicalPattern("M", "N") + val (M, N) = metaLogical("M", "N") program( rule("main", headReplaced( constraint("main") ), body( statement({ n -> n.set(10) }, N), diff --git a/reactor/Test/test/TestProgramBuilder.kt b/reactor/Test/test/TestProgramBuilder.kt index 8342a458..d4e12394 100644 --- a/reactor/Test/test/TestProgramBuilder.kt +++ b/reactor/Test/test/TestProgramBuilder.kt @@ -26,9 +26,9 @@ class TestProgramBuilder { programBuilder = MemProgramBuilder(sessionSolver) } - lateinit var programBuilder: ProgramBuilder + lateinit var programBuilder: MemProgramBuilder - private fun ProgramBuilder.addRules(rules: List) { + private fun MemProgramBuilder.addRules(rules: List) { rules.forEach { r -> addRule(r) } }