public override Metastructure MetaMetaUnify(Metastructure value, out IEnumerable<CutState> filter) { var s = value as Suspension; if (s == null) throw new ArgumentTypeException("MetaMetaUnify", "value", value, typeof(Suspension)); if (context != s.context) throw new ArgumentException("Can't unify suspended goals across PrologContexts."); filter = Prover(CombineGoals(DelayedGoal, s.DelayedGoal)); return MakeSuspension(null, CombineGoals(FrozenGoal, s.FrozenGoal)); }
internal override Metastructure MetaMetaUnify(Metastructure theirMetaStructure, PrologContext context) { var s = theirMetaStructure as Suspension; if (s == null) throw new ArgumentTypeException("MetaMetaUnify", "theirMetaStructure", theirMetaStructure, typeof(Suspension)); if (context != s.context) throw new ArgumentException("Can't unify suspended goals across PrologContexts."); context.WakeUpGoal(CombineGoals(DelayedGoal, s.DelayedGoal)); return MakeSuspension(null, CombineGoals(FrozenGoal, s.FrozenGoal)); }
internal IEnumerable <CutState> MetaUnify(Metastructure m) { if (IsBound) { throw new InvalidOperationException("Cannot meta-unify a bound variable"); } Metastructure old = MetaBinding; IEnumerable <CutState> filter = null; if (old != null) { var merged = old.MetaMetaUnify(m, out filter); if (merged != null) { mValue = merged; } else { // All we have a suspended goal, which is now in the filter // there's no frozen goal, so we just unbind the variable // and see what the filter does. mValue = this; } } else { mValue = m; } try { if (filter != null) #pragma warning disable 414, 168, 219 { // ReSharper disable UnusedVariable foreach (var ignore in filter) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 { yield return(CutState.Continue); } } else { yield return(CutState.Continue); } } finally { mValue = old; } }
IEnumerable <bool> UnifyMetaMeta(Metastructure myMetaStructure, Metastructure theirMetaStructure, LogicVariable them) { IEnumerable <CutState> filter; mValue = myMetaStructure.MetaMetaUnify(theirMetaStructure, out filter); them.Value = this; #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in filter) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 { yield return(false); } mValue = myMetaStructure; them.mValue = theirMetaStructure; //null; //them.IsBound = false; }
internal bool UnifyWithCanonicalValue(object value, PrologContext context) { if (!IsBound) { Metastructure m = MetaBinding; if (m == null) { // We're binding a truly unbound variable to something. if (value != this) { var xl = value as LogicVariable; if (xl != null) { Metastructure xm2; if ((xm2 = xl.MetaBinding) != null) { // We're binding a truly unbound variable to a meta-bound variable xl.UnifyMetaVar(xm2, this, context); return(true); } } SaveAndUpdate(value, context); // sets IsBound } return(true); } // This is an attributed (metabound) variable var l = value as LogicVariable; if (l == null) { UnifyMetaTerm(m, value, context); return(true); } Metastructure m2 = l.MetaBinding; if (m2 == null) { // Need to alias l to this, that's most easily done by letting l unify to this. UnifyMetaVar(m, l, context); return(true); } UnifyMetaMeta(m, m2, l, context); return(true); } return(Value.Equals(value)); }
IEnumerable <bool> UnifyMetaTerm(Metastructure m, object value) { Value = value; try { #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in m.MetaTermUnify(value)) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 { yield return(false); } } finally { mValue = m; //IsBound = false; } }
internal IEnumerable <bool> UnifyWithCanonicalValue(object value) { if (!IsBound) { Metastructure m = MetaBinding; if (m == null) { // We're binding a truly unbound variable to something. if (value != this) { var xl = value as LogicVariable; if (xl != null) { Metastructure xm2; if ((xm2 = xl.MetaBinding) != null) { // We're binding a truly unbound variable to a meta-bound variable return(xl.UnifyMetaVar(xm2, this)); } } Value = value; // sets IsBound } return(SucceedOnceAndThenUnBind()); } // This is an attributed (metabound) variable var l = value as LogicVariable; if (l == null) { return(UnifyMetaTerm(m, value)); } Metastructure m2 = l.MetaBinding; if (m2 == null) { // Need to alis l to this, that's most easily done by letting l unify to this. return(UnifyMetaVar(m, l)); } return(UnifyMetaMeta(m, m2, l)); } return(ToEnumerator(Value.Equals(value))); }
IEnumerable<bool> UnifyMetaMeta(Metastructure myMetaStructure, Metastructure theirMetaStructure, LogicVariable them) { IEnumerable<CutState> filter; object mergedMetaValue = myMetaStructure.MetaMetaUnify(theirMetaStructure, out filter); mValue = mergedMetaValue??this; them.Value = this; #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in filter) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 yield return false; mValue = myMetaStructure; them.mValue = theirMetaStructure; //null; //them.IsBound = false; }
/// <summary> /// This is an attributed variable with attribute myMetaStructure, unify it with attributed variable them, with attribute theirMetaStructure. /// </summary> /// <param name="myMetaStructure">This variable's metavalue</param> /// <param name="theirMetaStructure">The meta-value of the variable we're unifying with</param> /// <param name="them">The variable to unify with</param> /// <param name="context">Prolog context</param> void UnifyMetaMeta(Metastructure myMetaStructure, Metastructure theirMetaStructure, LogicVariable them, PrologContext context) { SaveAndUpdate(myMetaStructure.MetaMetaUnify(theirMetaStructure, context), context); them.SaveAndUpdate(this, context); }
internal IEnumerable<CutState> MetaUnify(Metastructure m) { if (IsBound) throw new InvalidOperationException("Cannot meta-unify a bound variable"); Metastructure old = MetaBinding; IEnumerable<CutState> filter = null; if (old != null) { var merged = old.MetaMetaUnify(m, out filter); if (merged != null) mValue = merged; else // All we have a suspended goal, which is now in the filter // there's no frozen goal, so we just unbind the variable // and see what the filter does. mValue = this; } else { mValue = m; } try { if (filter != null) #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in filter) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 yield return CutState.Continue; else yield return CutState.Continue; } finally { mValue = old; } }
internal IEnumerable<CutState> AddSuspendedGoal(Structure goal, PrologContext context) { var old = MetaBinding; mValue = new Metastructure(goal, null, context, old); try { yield return CutState.Continue; } finally { mValue = (object)old??this; } }
internal IEnumerable<CutState> AddFrozenGoal(Structure goal, PrologContext context) { var old = MetaBinding; mValue = new Metastructure(null, goal, context, old); try { yield return CutState.Continue; } finally { mValue = old; } }
/// <summary> /// This is an atributed variable with metastructure m, unify with unattributed and unbound variable v. /// </summary> /// <param name="m">This variable's metavalue</param> /// <param name="l">The completely unbound logic variable to which we are binding.</param> /// <param name="context">Prolog context</param> void UnifyMetaVar(Metastructure m, LogicVariable l, PrologContext context) { System.Diagnostics.Debug.Assert(l.MetaBinding == null); l.SaveAndUpdate(this, context); this.SaveAndUpdate(m.MetaVarUnify(l, context), context); }
/// <summary> /// This is an atributed variable with metastructure m, unify with unattributed and unbound variable v. /// </summary> /// <param name="m">This variable's metavalue</param> /// <param name="l">The completely unbound logic variable to which we are binding.</param> /// <param name="context">Prolog context</param> void UnifyMetaVar(Metastructure m, LogicVariable l, PrologContext context) { Debug.Assert(l.MetaBinding == null); l.SaveAndUpdate(this, context); this.SaveAndUpdate(m.MetaVarUnify(l, context), context); }
/// <summary> /// Merge the information from two Metastructures into one new metastructure. /// </summary> /// <param name="theirMetaStructure">The Metastructure to merge with.</param> /// <param name="context">Context in which to execute suspended goals.</param> /// <returns>The merged Metastructure.</returns> public Metastructure MetaMetaUnify(Metastructure theirMetaStructure, PrologContext context) { if (theirMetaStructure == null) throw new ArgumentTypeException("MetaMetaUnify", "theirMetaStructure", theirMetaStructure, typeof(Metastructure)); if (context != theirMetaStructure.Context) throw new ArgumentException("Can't unify suspended goals across PrologContexts."); context.WakeUpGoal(CombineGoals(DelayedGoal, theirMetaStructure.DelayedGoal)); return MakeSuspension(null, CombineGoals(FrozenGoal, theirMetaStructure.FrozenGoal)); }
/// <summary> /// This is an attributed variable with attribute m, unify it with value. /// </summary> /// <param name="m">Current attribute</param> /// <param name="value">Value to give it</param> /// <param name="context">Prolog context (to get trail and wakeup list)</param> /// <returns>Success</returns> void UnifyMetaTerm(Metastructure m, object value, PrologContext context) { Value = value; m.MetaTermUnify(value, context); }
internal abstract Metastructure MetaMetaUnify(Metastructure theirMetaStructure, PrologContext context);
void UnifyMetaVar(Metastructure m, LogicVariable l, PrologContext context) { System.Diagnostics.Debug.Assert(l.MetaBinding == null); l.SaveAndUpdate(this, context); m.MetaVarUnify(l, context); }
IEnumerable<bool> UnifyMetaTerm(Metastructure m, object value) { Value = value; try { #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in m.MetaTermUnify(value)) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 yield return false; } finally { mValue = m; //IsBound = false; } }
internal IEnumerable<CutState> MetaUnify(Metastructure m) { if (IsBound) throw new InvalidOperationException("Cannot meta-unify a bound variable"); Metastructure old = MetaBinding; IEnumerable<CutState> filter = null; mValue = old != null ? old.MetaMetaUnify(m, out filter) : m; try { if (filter != null) #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in filter) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 yield return CutState.Continue; else yield return CutState.Continue; } finally { mValue = old; } }
IEnumerable<bool> UnifyMetaVar(Metastructure m, LogicVariable l) { Debug.Assert(l.MetaBinding == null); l.Value = this; IEnumerable<CutState> goal; mValue = (object)m.MetaVarUnify(l, out goal)??this; try { #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in goal) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 yield return false; } finally { // Reset our own binding to its previous binding mValue = m; // Reset binding of l l.mValue = l; //l.IsBound = false; } }
public Metastructure(Structure delayedGoal, Structure frozenGoal, PrologContext prologContext, Metastructure old) : this(CombineGoals(delayedGoal, old?.DelayedGoal), CombineGoals(frozenGoal, old?.FrozenGoal), prologContext) { }
public abstract Metastructure MetaMetaUnify(Metastructure value, out IEnumerable<CutState> filter);