-

src/Yuuna.Contracts/Patterns/Builders/Cascadable.cs → src/Yuuna.Contracts/Artisan/Cascade/Cascadable.cs

@@ -1,4 +1,4 @@
-namespace Yuuna.Contracts.Patterns.Cascade
+namespace Yuuna.Contracts.Artisan.Cascade
 {
     using System.ComponentModel;
     /// <summary>

src/Yuuna.Contracts/Patterns/Builders/CascadeBuilder.cs → src/Yuuna.Contracts/Artisan/Cascade/CascadeBuilder.cs

@@ -1,6 +1,4 @@
-
-
-namespace Yuuna.Contracts.Patterns.Cascade
+namespace Yuuna.Contracts.Artisan.Cascade
 {
     using System;
     using System.Collections.Generic; 
@@ -12,9 +10,9 @@ namespace Yuuna.Contracts.Patterns.Cascade
     public sealed class CascadeBuilder<TNext> : Initial<TNext>
         where TNext : Cascadable, new()
     {
-        private readonly Action<IReadOnlyList<object>> _onCompleted;
+        private readonly Action<Queue<object>> _onCompleted;
 
-        private CascadeBuilder(Action<IReadOnlyList<object>> onCompleted)
+        private CascadeBuilder(Action<Queue<object>> onCompleted)
         {
             this._onCompleted = onCompleted;
         }
@@ -24,15 +22,15 @@ namespace Yuuna.Contracts.Patterns.Cascade
         /// </summary>
         /// <param name="onCompleted"></param>
         /// <returns></returns>
-        public static TNext Build(Action<IReadOnlyList<object>> onCompleted)
+        public static TNext Build(Action<Queue<object>> onCompleted)
         {
             if (onCompleted is null)
                 throw new ArgumentNullException(nameof(onCompleted));
             var init = new CascadeBuilder<TNext>(onCompleted);
-            return init.Next();
+            return init.MoveNext();
         }
 
-        protected override void OnCompleted(IReadOnlyList<object> session) => this._onCompleted(session);
+        protected override void OnCompleted(Queue<object> session) => this._onCompleted(session);
 
     }
 }

src/Yuuna.Contracts/Artisan/Cascade/Initial.cs

@@ -0,0 +1,63 @@
+namespace Yuuna.Contracts.Artisan.Cascade
+{
+    using System.Collections.Generic;
+    using System.Collections.Immutable;
+    using System.Runtime.CompilerServices;
+
+    /// <summary>
+    /// 初始級聯器。
+    /// 將繼承自這個級聯器的類別標示為整個級聯模式中的第一個級聯類型，用以連結下一個級聯物件。這是 <see langword="abstract"/> 類別。
+    /// </summary> 
+    /// <typeparam name="TNext">下個級聯類型。</typeparam>
+    public abstract class Initial<TNext, T> : Cascadable
+        where TNext : Cascadable, new()
+    {
+        protected Initial()
+        {
+        }
+
+        protected abstract void OnCompleted(Queue<object> session);
+
+
+        /// <summary>
+        /// 將資料存入內部工作階段(Session)物件中後建立並傳回下一個 <see cref="TNext"/> 類型的新物件實體。
+        /// </summary>
+        /// <param name="data">資料。</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected TNext MoveNext(T data)
+        {
+            var session = new Session() as IInternalSession;
+            session.Completed += this.OnCompleted;
+            session.Store(data);  
+            return new TNext { Session = session };
+        }
+    }
+
+    /// <summary>
+    /// 初始級聯器。
+    /// 將繼承自這個級聯器的類別標示為整個級聯模式中的第一個級聯類型，用以連結下一個級聯物件。這是 <see langword="abstract"/> 類別。
+    /// </summary> 
+    /// <typeparam name="TNext">下個級聯類型。</typeparam>
+    public abstract class Initial<TNext> : Cascadable
+        where TNext : Cascadable, new()
+    {
+        protected Initial()
+        {
+        }
+
+        protected abstract void OnCompleted(Queue<object> session);
+
+        /// <summary>
+        /// 傳回下一個 <see cref="TNext"/> 類型的新物件實體。
+        /// </summary>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected TNext MoveNext()
+        {
+            var session = new Session() as IInternalSession;
+            session.Completed += this.OnCompleted; 
+            return new TNext { Session = session };
+        }
+         
+    }
+}

src/Yuuna.Contracts/Patterns/Builders/Internal/IInternalEventBus.cs → src/Yuuna.Contracts/Artisan/Cascade/Internal/IInternalEventBus.cs

@@ -1,12 +1,13 @@
 
-namespace Yuuna.Contracts.Patterns.Cascade
+namespace Yuuna.Contracts.Artisan.Cascade 
 {
     using System;
     using System.Collections.Generic;
+    using System.Collections.Immutable;
 
     internal interface IInternalEventDataBus
     {
-        event Action<IReadOnlyList<object>> Completed;
+        event Action<Queue<object>> Completed;
         void OnComplete();
     }
 }

src/Yuuna.Contracts/Patterns/Builders/Internal/IInternalSession.cs → src/Yuuna.Contracts/Artisan/Cascade/Internal/IInternalSession.cs

@@ -1,10 +1,10 @@
 
-namespace Yuuna.Contracts.Patterns.Cascade
+namespace Yuuna.Contracts.Artisan.Cascade
 {
     using System.Collections.Generic;
     using System.Collections.Immutable;
 
-    internal interface IInternalSession : IInternalStorage, IInternalEventDataBus, IReadOnlyList<object>
+    internal interface IInternalSession : IInternalStorage, IInternalEventDataBus, IReadOnlyCollection<object>
     { 
     }
 }

src/Yuuna.Contracts/Patterns/Builders/Internal/IInternalStorage.cs → src/Yuuna.Contracts/Artisan/Cascade/Internal/IInternalStorage.cs

@@ -1,5 +1,5 @@
 
-namespace Yuuna.Contracts.Patterns.Cascade
+namespace Yuuna.Contracts.Artisan.Cascade
 {  
     internal interface IInternalStorage
     {

src/Yuuna.Contracts/Patterns/Builders/Internal/Session.cs → src/Yuuna.Contracts/Artisan/Cascade/Internal/Session.cs

@@ -1,5 +1,5 @@
 
-namespace Yuuna.Contracts.Patterns.Cascade
+namespace Yuuna.Contracts.Artisan.Cascade
 {
     using System;
     using System.Collections;
@@ -8,45 +8,37 @@ namespace Yuuna.Contracts.Patterns.Cascade
 
     internal sealed class Session : IInternalSession
     {
-        private readonly List<object> _q;
+        private readonly Queue<object> _q;
         private readonly object _lockObject;
         internal Session()
         {
             this._lockObject = new object();
-            this._q = new List<object>();
+            this._q = new Queue<object>();
         }
 
         #region IInternalEventDataBus 
 
-        private event Action<IReadOnlyList<object>> _completed;
+        private event Action<Queue<object>> _completed;
 
-        event Action<IReadOnlyList<object>> IInternalEventDataBus.Completed
+        event Action<Queue<object>> IInternalEventDataBus.Completed
         {
             add => this._completed += value;
             remove => this._completed -= value;
         }
 
-        void IInternalEventDataBus.OnComplete() => this._completed?.Invoke(this);
+        void IInternalEventDataBus.OnComplete() => this._completed?.Invoke(this._q);
         #endregion
 
         #region IInternalStorage 
         void IInternalStorage.Store<T>(T data)
         {
             lock (this._lockObject)
-                this._q.Add(data);
+                this._q.Enqueue(data);
         }
         #endregion
 
         #region IReadOnlyList<object>
-
-        public object this[int index]
-        {
-            get
-            {
-                lock (this._lockObject)
-                    return this._q[index];
-            }
-        }
+         
 
         public int Count
         {

src/Yuuna.Contracts/Patterns/Builders/Output.cs → src/Yuuna.Contracts/Artisan/Cascade/Output.cs

@@ -1,6 +1,6 @@
 
 
-namespace Yuuna.Contracts.Patterns.Cascade
+namespace Yuuna.Contracts.Artisan.Cascade
 {
     using System.Runtime.CompilerServices;
 
@@ -20,7 +20,7 @@ namespace Yuuna.Contracts.Patterns.Cascade
         /// </summary>
         /// <param name="data">資料。</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected void StoreData(T data)
+        protected void MoveNext(T data)
         {
             this.Session.Store(data);
             this.Session.OnComplete();

src/Yuuna.Contracts/Patterns/Builders/Pipeline.cs → src/Yuuna.Contracts/Artisan/Cascade/Pipeline.cs

@@ -1,5 +1,5 @@
 
-namespace Yuuna.Contracts.Patterns.Cascade
+namespace Yuuna.Contracts.Artisan.Cascade
 {
     using System.Runtime.CompilerServices;
 
@@ -7,9 +7,9 @@ namespace Yuuna.Contracts.Patterns.Cascade
     /// 管道級聯器。
     /// 將繼承自這個級聯器的類別標示為整個級聯模式中的中間級級聯物件，用以連結下一個級聯物件。這是 <see langword="abstract"/> 類別。
     /// </summary>
-    /// <typeparam name="T"></typeparam>
     /// <typeparam name="TNext">下個級聯類型。</typeparam>
-    public abstract class Pipeline<T, TNext> : Cascadable
+    /// <typeparam name="T"></typeparam>
+    public abstract class Pipeline< TNext, T> : Cascadable
         where TNext : Cascadable, new()
     {
 
@@ -18,11 +18,11 @@ namespace Yuuna.Contracts.Patterns.Cascade
         }
 
         /// <summary>
-        /// 將資料存入內部工作階段(Session)物件中後建立並返回新的 <see cref="TNext"/> 物件實體。
+        /// 將資料存入內部工作階段(Session)物件中後建立並傳回下一個 <see cref="TNext"/> 類型的新物件實體。
         /// </summary>
         /// <param name="data">資料。</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected TNext StoreData(T data)
+        protected TNext MoveNext(T data)
         {
             this.Session.Store(data);
             return new TNext { Session = this.Session };

src/Yuuna.Contracts/Artisan/Cascade/readme.md

@@ -0,0 +1,11 @@
+# 級聯型生成器模式 (Cascade Builder Pattern)
+
+## 介紹及使用方式
+> 級聯型生成器模式，較傳統生成器模式多了流程引導，此種設計模式可以有效引導套件使用者使用函式。
+
+級聯元件具有三種
+- 初始級聯器：```Initial<TNext>``` 及 ```Initial<TNext, T>``` 
+- 管道級聯器：```Pipeline<TNext, T>```
+- 輸出級聯器：```Output<T>```
+
+> 實作時，建議用堆疊式思維設計每個級聯器，也就是由 ***Output*** 類別開始至 ***Initial*** 類別。

src/Yuuna.Contracts/GroupManager.cs

@@ -10,7 +10,7 @@
 
         internal sealed class GroupManager : IGroupManager
         {
-            private volatile Dictionary<string, IGroup> _groups;
+            private readonly Dictionary<string, IGroup> _groups;
             private readonly object _lock = new object();
             internal GroupManager()
             {

src/Yuuna.Contracts/Optimization/IScore.cs

@@ -8,7 +8,7 @@ namespace Yuuna.Contracts.Optimization
 
     public interface IScore
     {
-        IGrammar Contrast { get; }
+        IPattern Contrast { get; }
         IImmutableList<IPair> SequentialMatches { get; }
 
         double Coverage { get; }

src/Yuuna.Contracts/Optimization/Score.cs

@@ -9,7 +9,7 @@ namespace Yuuna.Contracts.Optimization
 
     internal struct Score : IScore
     {
-        internal Score(PluginBase owner,IImmutableList<IPair> matches, IGrammar contrast)
+        internal Score(PluginBase owner,IImmutableList<IPair> matches, IPattern contrast)
         {
             this.Contrast = contrast;
             this.Plugin = owner;
@@ -25,7 +25,7 @@ namespace Yuuna.Contracts.Optimization
         /// <summary>
         /// 比較的文法。
         /// </summary>
-        public IGrammar Contrast { get; }
+        public IPattern Contrast { get; }
 
         public bool IsCompacted { get; }
         public double Coverage { get; }

src/Yuuna.Contracts/Optimization/StrategyBase.cs

@@ -24,13 +24,13 @@ namespace Yuuna.Contracts.Optimization
         protected abstract IComparer<IScore> Comparer { get; }
 
 
-        internal IImmutableList<IScore> Assess(PluginBase plugin, IImmutableList<string> words, IGrammarSet set)
+        internal IImmutableList<IScore> Assess(PluginBase plugin, IImmutableList<string> words, IPatternSet set)
         {
             var scores = new List<IScore>();
             var immutable = set.ToImmutable();
-            foreach (var grammar in immutable)
+            foreach (var pattern in immutable)
             {
-                var score = this.Evaluate(plugin,words, grammar);
+                var score = this.Evaluate(plugin,words, pattern);
                 if (score.SequentialMatches.Count > 0) // 過濾掉符合為 0 的文法
                     scores.Add(score);
             }
@@ -44,11 +44,11 @@ namespace Yuuna.Contracts.Optimization
         /// </summary>
         /// <param name="words"></param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private IScore Evaluate(PluginBase plugin ,IImmutableList<string> words, IGrammar grammar)
+        private IScore Evaluate(PluginBase plugin ,IImmutableList<string> words, IPattern pattern)
         {
             var matches = ImmutableArray.CreateBuilder<IPair>();
 
-            using (var iterator = grammar.ToImmutable().GetEnumerator())
+            using (var iterator = pattern.ToImmutable().GetEnumerator())
             {
                 iterator.MoveNext();
                 foreach (var word in words)
@@ -62,7 +62,7 @@ namespace Yuuna.Contracts.Optimization
                 }
             }
 
-            return new Score(plugin, matches.ToImmutable(), grammar);
+            return new Score(plugin, matches.ToImmutable(), pattern);
         }
     }
 

src/Yuuna.Contracts/Patterns/Builders/Initial.cs

@@ -1,27 +0,0 @@
-namespace Yuuna.Contracts.Patterns.Cascade
-{
-    using System.Collections.Generic;
-
-    /// <summary>
-    /// 初始級聯器。
-    /// 將繼承自這個級聯器的類別標示為整個級聯模式中的第一個級聯類型，用以連結下一個級聯物件。這是 <see langword="abstract"/> 類別。
-    /// </summary> 
-    /// <typeparam name="TNext">下個級聯類型。</typeparam>
-    public abstract class Initial<TNext> : Cascadable
-        where TNext : Cascadable, new()
-    {
-        protected Initial()
-        {
-            this.Session = new Session();
-            this.Session.Completed += this.OnCompleted;
-        }
-
-        protected abstract void OnCompleted(IReadOnlyList<object> session);
-
-        /// <summary>
-        /// 建立新的 <typeparamref name="TNext"/> 級聯器實體。
-        /// </summary>
-        /// <returns></returns>
-        public TNext Next() => new TNext { Session = this.Session };
-    }
-}

src/Yuuna.Contracts/Patterns/Builders/readme.md

@@ -1,13 +0,0 @@
-# 級聯型生成器模式 (Cascade Builder Pattern)
-
-## 介紹及使用方式
-級聯型生成器模式，較傳統生成器模式多了流程引導，此種設計模式可以有效引導套件使用者使用函式。
-
-級聯元件具有三種
-- 初始級聯器 ```Initial<TNext>```
-- 管道級聯器 ```Pipeline<T,TNext>```
-- 輸出級聯器 ```Output<T>```
-
-連結模式
-Initial<TFirst> --> TFirst: Pipeline<T,TSecond> --> TSecond: Pipeline<T,...> -->
-... TLast: Output<T>

src/Yuuna.Contracts/Patterns/Delegates.cs

@@ -0,0 +1,15 @@
+
+namespace Yuuna.Contracts.Patterns
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Immutable;
+    using System.Diagnostics;
+    using Yuuna.Contracts.Interaction;
+    using Yuuna.Contracts.Optimization;
+    using Yuuna.Contracts.Semantics;
+
+    public delegate Response Invoke(IScore score);
+
+    public delegate Response Incomplete(IScore score);
+}

src/Yuuna.Contracts/Patterns/IBehaviourBuilder.cs

@@ -1,19 +0,0 @@
-
-namespace Yuuna.Contracts.Patterns
-{
-    using System;
-    using System.Collections.Generic;
-    using Yuuna.Contracts.Interaction;
-    using Yuuna.Contracts.Optimization;
-    using Yuuna.Contracts.Semantics;
-
-    public interface IBehaviourBuilder
-    {
-        /// <summary>
-        /// 當文法完全吻合時將觸發這段函式。
-        /// </summary>
-        /// <param name="behaviour"></param>
-        void OnInvoke(Behaviour behaviour);
-    }
-
-}

src/Yuuna.Contracts/Patterns/IIncompleteBuilder.cs

@@ -0,0 +1,7 @@
+namespace Yuuna.Contracts.Patterns
+{
+    public interface IIncompleteBuilder
+    {
+        void OnImcomplete(Incomplete incomplete);
+    }
+}

src/Yuuna.Contracts/Patterns/IInvokeBuilder.cs

@@ -0,0 +1,7 @@
+namespace Yuuna.Contracts.Patterns
+{
+    public interface IInvokeBuilder
+    {
+        IIncompleteBuilder OnInvoke(Invoke invoke);
+    }
+}

src/Yuuna.Contracts/Patterns/IGrammar.cs → src/Yuuna.Contracts/Patterns/IPattern.cs

@@ -6,7 +6,7 @@ namespace Yuuna.Contracts.Patterns
     using Yuuna.Contracts.Linq;
     using Yuuna.Contracts.Semantics;
 
-    public interface IGrammar : IEquatable<IGrammar>, IImmutable<IGroup>
+    public interface IPattern : IEquatable<IPattern>, IImmutable<IGroup>
     {
         int Count { get; }
 

src/Yuuna.Contracts/Patterns/IPatternBuilder.cs

@@ -1,17 +1,10 @@
 
 namespace Yuuna.Contracts.Patterns
 {
-    using System.Collections.Immutable;
     using Yuuna.Contracts.Semantics;
 
     public interface IPatternBuilder
     {
-        /// <summary>
-        /// 建立新文法規則。
-        /// </summary>
-        /// <param name="group"></param>
-        /// <param name="groups"></param>
-        /// <returns></returns>
-        IBehaviourBuilder Build(IGroup group, params IGroup[] groups);
+        IInvokeBuilder Build(IGroup group, params IGroup[] rest);
     }
 }

src/Yuuna.Contracts/Patterns/IGrammarSet.cs → src/Yuuna.Contracts/Patterns/IPatternSet.cs

@@ -4,9 +4,9 @@ namespace Yuuna.Contracts.Patterns
     using System.Collections.Immutable;
     using Yuuna.Contracts.Linq;
 
-    public interface IGrammarSet : IImmutable<IGrammar>
+    public interface IPatternSet : IImmutable<IPattern>
     {
-        bool TryGet(IGrammar grammar, out Behaviour behaviour); 
+        bool TryGet(IPattern pattern, out Invoke invoke); 
     }
 
 }

src/Yuuna.Contracts/Patterns/Internal/Bag.cs

@@ -0,0 +1,10 @@
+
+namespace Yuuna.Contracts.Patterns
+{
+    internal struct Bag
+    {
+        internal IPattern Pattern;
+        internal Invoke Invoke;
+        internal Incomplete Incomplete;
+    }
+}

src/Yuuna.Contracts/Patterns/Internal/BehaviourBuilder.cs

@@ -1,33 +0,0 @@
-
-namespace Yuuna.Contracts.Patterns
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Collections.Immutable;
-    using System.Diagnostics;
-    using Yuuna.Contracts.Interaction;
-    using Yuuna.Contracts.Optimization;
-    using Yuuna.Contracts.Semantics;
-
-    internal struct BehaviourBuilder : IBehaviourBuilder
-    {
-        private readonly Action<IGrammar, Behaviour> _addMethod;
-        private readonly IGrammar _grammar;
-
-        internal BehaviourBuilder(Action<IGrammar, Behaviour> addMethod, IGrammar grammar)
-        {
-            Debug.Assert(addMethod != null);
-            Debug.Assert(grammar != null);
-            this._addMethod = addMethod;
-            this._grammar = grammar;
-        }
-
-        void IBehaviourBuilder.OnInvoke(Behaviour callback)
-        {
-            if (callback is null)
-                throw new ArgumentNullException(nameof(callback));
-            this._addMethod.Invoke(this._grammar, callback);
-        }
-    }
-    public delegate Response Behaviour(IScore score);
-}

src/Yuuna.Contracts/Patterns/Internal/IncompleteBuilder.cs

@@ -0,0 +1,16 @@
+
+namespace Yuuna.Contracts.Patterns
+{
+    using System;
+    using Yuuna.Contracts.Artisan.Cascade;
+
+    internal sealed class IncompleteBuilder : Output<Incomplete>, IIncompleteBuilder
+    {
+        public void OnImcomplete(Incomplete incomplete)
+        {
+            if (incomplete is null)
+                throw new ArgumentNullException(nameof(incomplete));
+            this.MoveNext(incomplete);
+        }
+    } 
+}

src/Yuuna.Contracts/Patterns/Internal/InvokeBuilder.cs

@@ -0,0 +1,16 @@
+
+namespace Yuuna.Contracts.Patterns
+{
+    using System;
+    using Yuuna.Contracts.Artisan.Cascade;
+
+    internal sealed class InvokeBuilder : Pipeline<IncompleteBuilder, Invoke>, IInvokeBuilder
+    {
+        public IIncompleteBuilder OnInvoke(Invoke invoke)
+        {
+            if (invoke is null)
+                throw new ArgumentNullException(nameof(invoke));
+            return this.MoveNext(invoke);
+        }
+    } 
+}

src/Yuuna.Contracts/Patterns/Internal/PatternBuilder.cs

@@ -1,51 +0,0 @@
-
-namespace Yuuna.Contracts.Patterns
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Concurrent;
-    using System.Collections.Generic;
-    using System.Collections.Immutable;
-    using System.Diagnostics;
-    using System.Diagnostics.CodeAnalysis;
-    using System.Linq;
-    using System.Text;
-    using Yuuna.Contracts.Interaction;
-    using Yuuna.Contracts.Optimization;
-    using Yuuna.Contracts.Semantics;
-
-
-
-    internal sealed class PatternBuilder :  IGrammarSet, IPatternBuilder 
-    {
-        private readonly ImmutableDictionary<IGrammar, Behaviour>.Builder _rules;
-        internal PatternBuilder() 
-        {
-            this._rules = ImmutableDictionary.CreateBuilder<IGrammar, Behaviour>(EqualityComparer<IGrammar>.Default); 
-        }
-        public IImmutableList<IGrammar> ToImmutable()
-        {
-            return this._rules.Keys.ToImmutableArray();
-        }
-        public bool TryGet(IGrammar grammar, out Behaviour behaviour)
-        {
-            return this._rules.TryGetValue(grammar, out behaviour);
-        } 
-        IBehaviourBuilder IPatternBuilder.Build(IGroup group, params IGroup[] rest)
-        {
-            if (group is null)
-                throw new ArgumentNullException(nameof(group));
-            var g = new Grammar();
-            g.Add(group);
-            if (rest != null)
-                foreach (var item in rest)
-                {
-                    g.Add(item);
-                }
-            g.Immute();
-            return new BehaviourBuilder(this._rules.Add, g);
-        }
-
-    }
-
-}

src/Yuuna.Contracts/Patterns/Internal/PatternFactory.cs

@@ -0,0 +1,56 @@
+
+namespace Yuuna.Contracts.Patterns
+{
+    using System;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Collections.Immutable;
+    using Yuuna.Contracts.Artisan.Cascade;
+    using Yuuna.Contracts.Semantics;
+
+    internal sealed class PatternFactory : Initial<InvokeBuilder,IPattern>, IPatternSet, IPatternBuilder
+    { 
+        private readonly ConcurrentDictionary<IPattern, Bag> _list;
+        public PatternFactory()
+        {
+            this._list = new ConcurrentDictionary<IPattern, Bag>();
+        }
+
+        protected override void OnCompleted(Queue<object> session)
+        { 
+                 
+            var ge = new Bag
+            {
+                Pattern = session.Dequeue() as IPattern,
+                Invoke = session.Dequeue() as Invoke,
+                Incomplete = session.Dequeue() as Incomplete,
+            };
+            System.Console.WriteLine(this._list.TryAdd(ge.Pattern, ge));
+        }
+         
+        public bool TryGet(IPattern pattern, out Invoke invoke)
+        {
+            var b = this._list.TryGetValue(pattern, out var s);
+            System.Console.WriteLine(b);
+            invoke = s.Invoke;
+            return b;
+        }
+        public IImmutableList<IPattern> ToImmutable() => this._list.Keys.ToImmutableArray();
+
+        public IInvokeBuilder Build(IGroup group, params IGroup[] rest)
+        {
+
+            if (group is null)
+                throw new ArgumentNullException(nameof(group));
+
+            var g = new Pattern();
+            g.Add(group);
+            if (rest != null)
+                foreach (var item in rest)
+                    g.Add(item);
+            g.Immute();
+
+            return this.MoveNext(g);
+        }
+    }
+}

src/Yuuna.Contracts/Patterns/Internal/Grammar.cs → src/Yuuna.Contracts/Patterns/Pattern.cs

@@ -7,14 +7,14 @@ namespace Yuuna.Contracts.Patterns
     using System.Linq;
     using System.Diagnostics;
 
-    public sealed class Grammar : IGrammar
+    public sealed class Pattern : IPattern
     { 
         public IImmutableList<string> SequentialKeys { get; private set; }
         private IImmutableList<IGroup> _groups;
 
         private readonly ImmutableArray<string>.Builder _keyBuilder;
         private readonly ImmutableArray<IGroup>.Builder _groupBuilder;
-        internal Grammar()
+        internal Pattern()
         {
             this._keyBuilder = ImmutableArray.CreateBuilder<string>();
             this._groupBuilder = ImmutableArray.CreateBuilder<IGroup>();
@@ -48,7 +48,7 @@ namespace Yuuna.Contracts.Patterns
             return this._groups;
         }
 
-        public bool Equals( IGrammar other)
+        public bool Equals( IPattern other)
         {
             Debug.Assert(this.SequentialKeys != null);
             return this.SequentialKeys.SequenceEqual(other.SequentialKeys);

src/Yuuna.Contracts/Plugins/Fake.cs

@@ -9,7 +9,7 @@ namespace Yuuna.Contracts.Plugins
     public sealed class Fake : PluginBase
     {
         protected override void BuildPatterns(IGroupManager g, IPatternBuilder p)
-        { 
+        {
             g.Define("open").AppendOrCreate(new[] { "打開", "開" });
             g.Define("door").AppendOrCreate(new[] { "門", "房間門" });
             g.Define("light").AppendOrCreate(new[] { "燈", "檯燈" });
@@ -22,18 +22,18 @@ namespace Yuuna.Contracts.Plugins
                 if (!DOOR.IS_OPENED)
                     return (Moods.Happy, "已經開好門囉 <3");
                 else
-                    return (Moods.Sad, "可是門本來就是開的欸 QAQ");  
-            });
+                    return (Moods.Sad, "可是門本來就是開的欸 QAQ");
+            }).OnImcomplete(s=>"");
 
             p.Build(g["open"], g["light"]).OnInvoke(score =>
             {
-                var LIGHT = new { IS_OPENED = new[] { true, false,true,false }.RandomTakeOne() };
+                var LIGHT = new { IS_OPENED = new[] { true, false, true, false }.RandomTakeOne() };
                 // 開門
                 if (!LIGHT.IS_OPENED)
                     return (Moods.Happy, "已經開好燈囉 <3");
                 else
                     return (Moods.Sad, "可是燈本來就是開的欸 QAQ");
-            });
+            }).OnImcomplete(s => "");
 
             //p.Build(g["open"], g["browser"]).OnInvoke(score =>
             //{

src/Yuuna.Contracts/Plugins/PluginBase.cs

@@ -8,78 +8,17 @@ namespace Yuuna.Contracts.Plugins
     using Yuuna.Contracts.Interaction;
     using Yuuna.Contracts.Optimization;
     using Yuuna.Contracts.Patterns;
-    using Yuuna.Contracts.Patterns.Cascade;
+    using Yuuna.Contracts.Artisan.Cascade;
     using Yuuna.Contracts.Semantics;
     using Yuuna.Contracts.TextSegmention;
-
-    public delegate Response Invoke(IScore score);
-    public delegate Response Incomplete(IScore score);
-
-    public interface IInvokeCreator
-    {
-        IIncompleteCreator OnInvoke(Invoke invoke);
-    }
-
-    public interface IIncompleteCreator
-    {
-        void OnIncomplete(Incomplete incomplete);
-    }
      
-    public sealed class IncompleteCreator : Output<Incomplete>, IIncompleteCreator
-    {
-        public void OnIncomplete(Incomplete incomplete)
-        {
-            //if (incomplete is null)
-            //    throw new ArgumentNullException(nameof(incomplete));
-            this.StoreData( incomplete);
-        }
-    }
-
-    public sealed class InvokeCreator : Pipeline<Invoke, IncompleteCreator>, IInvokeCreator
-    {
-        public IIncompleteCreator OnInvoke(Invoke invoke)
-        {
-            //if (invoke is null)
-            //    throw new ArgumentNullException(nameof(invoke));
-
-            return this.StoreData(invoke);
-        }
-    }
-
-    public interface IGrammarCreator
-    {
-        IInvokeCreator Build(IGroup group, params IGroup[] rest);
-    }
-
-    public sealed class GrammarCreator : Pipeline<IGrammar, InvokeCreator>, IGrammarCreator
-    {
-        public IInvokeCreator Build(IGroup group, params IGroup[] rest)
-        {
-            //if (group is null)
-            //    throw new ArgumentNullException(nameof(group));
-            var g = new Grammar();
-            //g.Add(group);
-            //if (rest != null)
-            //    foreach (var item in rest)
-            //    {
-            //        g.Add(item);
-            //    }
-            //g.Immute();
-
-            return this.StoreData( g);
-        }
-    }
-     
-
-
     public abstract class PluginBase
     {
-        private readonly PatternBuilder _grammarSet; 
-         
+        private readonly PatternFactory _patternfactory;
 
         public PluginBase()
         {
-            this._grammarSet = new PatternBuilder();
+            this._patternfactory = new PatternFactory();
         }
 
         /// <summary>
@@ -94,17 +33,17 @@ namespace Yuuna.Contracts.Plugins
         {
             try
             {
-                
-
                 this.BeforeInitialize(textSegmenter);
+
                 var groupManager = new GroupManager();
-                this.BuildPatterns(groupManager, this._grammarSet);
+                this.BuildPatterns(groupManager, this._patternfactory );
                 textSegmenter.Load(groupManager);
                 this.AfterInitialize();
                 return true;
             }
-            catch
+            catch(Exception e)
             {
+                Console.WriteLine(e);
                 return false;
             }
         }
@@ -124,13 +63,13 @@ namespace Yuuna.Contracts.Plugins
         protected abstract void BuildPatterns(IGroupManager g, IPatternBuilder p);
 
         internal IImmutableList<IScore> Evaluate(StrategyBase strategy, IImmutableList<string> cutted)
-        {
-            return strategy.Assess(this, cutted, this._grammarSet);
+        { 
+            return strategy.Assess(this, cutted, this._patternfactory);
         }
 
-        internal Behaviour SelectBest(IScore score)
+        internal Invoke SelectBest(IScore score)
         {
-            return this._grammarSet.TryGet(score.Contrast, out var b) ? b : null;
+            return this._patternfactory.TryGet(score.Contrast, out var b) ? b : null;
         }
     }
 

src/Yuuna.Contracts/Plugins/PluginGateway.cs

@@ -7,60 +7,18 @@ namespace Yuuna.Contracts.Plugins
     using System.Linq;
     using System.Text;
     using Yuuna.Contracts.Optimization;
-    using Yuuna.Contracts.Patterns.Cascade;
+    using Yuuna.Contracts.Artisan.Cascade;
     using Yuuna.Contracts.Patterns;
     using Yuuna.Contracts.TextSegmention;
     using Yuuna.Contracts.Utilities;
 
     public class PluginGateway
-    {
-        public PluginGateway()
-        {
-
-        }
-
-        class A : Pipeline<string,B>
-        {
-            public B a(string v)
-            {
-                return this.StoreData(v);
-            }
-        }
-        class B : Pipeline<string,C>
-        {
-            public C b(string v)
-            {
-                return this.StoreData(v);
-            }
-        }
-        class C : Pipeline<string, D>
-        {
-            public D c(string v)
-            {
-                return this.StoreData(v);
-            }
-        } 
-        class D: Output<string>
-        {
-            public void d(string v)
-            {
-                this.StoreData(v);
-            }
-        }
-
+    { 
         public static void Main(string[] args)
-        {
-            var builder = CascadeBuilder<A>.Build(session => 
-            {
-                foreach (var item in session)
-                {
-                    Console.WriteLine(item);
-                }
-            });
-            builder.a("---a").b("---b").c("---c").d("---d");
+        { 
             // Send("打開門");
             // Send("開燈");
-            // Send("打開燈"); 
+              Send("打開燈"); 
         }
 
         public static void Send(string text)
@@ -75,7 +33,7 @@ namespace Yuuna.Contracts.Plugins
 
             Console.WriteLine("我: " + text);
             var cutted = segmenter.Cut(text);
-            //Console.WriteLine($"來自分詞器 {segmenter.Name} 的分詞結果: [ {string.Join(", ",cutted)} ]");
+            Console.WriteLine($"來自分詞器 {segmenter.Name} 的分詞結果: [ {string.Join(", ",cutted)} ]");
             var strategy = new DefaultStrategy();
             var list = new List<IScore>();
             foreach (var p in allPlugins) 
@@ -99,6 +57,7 @@ namespace Yuuna.Contracts.Plugins
                 {
                     case 1:
                         {
+                            Console.WriteLine("#1");
                             sb.Append("你" + new[] { "是想", "想要" }.RandomTakeOne() + " ");
                             sb.Append(choices.Select(x => x.Contrast.ToImmutable().Aggregate(string.Empty, (s, g) => s += g.ToImmutable().RandomTakeOne().ToImmutable().RandomTakeOne())));
                             sb.Append(" 嗎?");
@@ -108,6 +67,7 @@ namespace Yuuna.Contracts.Plugins
 
                     case 2:
                         {
+                            Console.WriteLine("#2");
                             sb.Append("你" + new[] { "是想", "想要" }.RandomTakeOne() + " ");
                             sb.AppendJoin(" 還是 ", choices.Select(x => x.Contrast.ToImmutable().Aggregate(string.Empty, (s, g) => s += g.ToImmutable().RandomTakeOne().ToImmutable().RandomTakeOne())));
                             sb.Append(" ?");
@@ -116,6 +76,7 @@ namespace Yuuna.Contracts.Plugins
 
 
                     default:
+                        Console.WriteLine("#n");
                         sb.Append("我不太清楚你想做什麼");
                         break;
                 }

src/Yuuna.Contracts/TextSegmention/JiebaSegmenter.cs

@@ -16,22 +16,23 @@ namespace Yuuna.Contracts.TextSegmention
         string ITextSegmenter.Name => "Jieba.Net";
         public IImmutableList<string> Cut(string text) => this._jieba.Cut(text, true, true).ToImmutableArray();
         public void Load(IGroupManager manager)
-        {
+        { 
             if (manager == null)
                 return;
 
             foreach (var name in manager.Keys)
             {
-                //Console.WriteLine(name);
+                Console.WriteLine("name: " + name);
                 foreach (var synonym in manager[name].ToImmutable())
                 {
-                    //Console.WriteLine("added: " + synonym.ToImmutable().Count);
+                    Console.WriteLine("  count: " + synonym.ToImmutable().Count);
                     foreach (var w in synonym.ToImmutable())
                     {
-                        //Console.WriteLine("added: " + w);
+                        Console.WriteLine("  added: " + w);
                         this._jieba.AddWord(w);
                     }
                 }
+                Console.WriteLine();
             }
         }