fix typo

src/Yuuna.Contracts/Group.cs

@@ -24,11 +24,11 @@
             {
                 Debug.Assert(!string.IsNullOrWhiteSpace(key), "'groupName' can't be null or empty.");
                 this.Key = key;
-                this._synosyms = ImmutableArray.CreateBuilder<ISynosym>();
+                this._synonyms = ImmutableArray.CreateBuilder<ISynonym>();
             }
 
 
-            private readonly ImmutableArray<ISynosym>.Builder _synosyms;
+            private readonly ImmutableArray<ISynonym>.Builder _synonyms;
              
 
             /// <summary> 
@@ -38,45 +38,45 @@
             /// <param name="words">欲關聯至此物件的多個單字。若此群組物件不包含任何與此參數相關的單字，則使用此參數建立新同義詞實體。</param> 
             /// <param name="stringComparer">字串比對器。</param>
             /// <exception cref="ArgumentNullException"/>
-            public ISynosym AppendOrCreate(IEnumerable<string> words, StringComparer stringComparer = null)
+            public ISynonym AppendOrCreate(IEnumerable<string> words, StringComparer stringComparer = null)
             {
                 if (words is null)
                     throw new ArgumentNullException(nameof(words));
 
                 //Console.WriteLine(string.Join(":", words));
 
-                foreach (var synosym in this._synosyms)
+                foreach (var synonym in this._synonyms)
                 { 
-                    if (synosym.Equals(words))
+                    if (synonym.Equals(words))
                     {
-                        synosym.AddRange(words);
-                        return synosym;
+                        synonym.AddRange(words);
+                        return synonym;
                     }
                 }
 
-                var inst = new Synosym(this, stringComparer);
+                var inst = new Synonym(this, stringComparer);
                 inst.AddRange(words);
-                this._synosyms.Add(inst);
+                this._synonyms.Add(inst);
                 return inst;
             }
 
-            public bool TryGetSynosym(string word, out ISynosym synosyms)
+            public bool TryGetSynonym(string word, out ISynonym synonyms)
             {
-                foreach (var synosym in this._synosyms)
+                foreach (var synonym in this._synonyms)
                 {
-                    if (synosym.Equals(word))
+                    if (synonym.Equals(word))
                     {
-                        synosyms = synosym;
+                        synonyms = synonym;
                         return true;
                     }
                 }
-                synosyms = null;
+                synonyms = null;
                 return false;
             } 
 
-            public IImmutableList<ISynosym> ToImmutable()
+            public IImmutableList<ISynonym> ToImmutable()
             {
-                return this._synosyms.ToImmutable();
+                return this._synonyms.ToImmutable();
             }
 
             /// <summary>

src/Yuuna.Contracts/Optimization/IPair.cs

@@ -5,6 +5,6 @@ namespace Yuuna.Contracts.Optimization
     public interface IPair
     {
         string Key { get; }
-        ISynosym Synosym { get; }
+        ISynonym Synonym { get; }
     }
 }

src/Yuuna.Contracts/Optimization/Pair.cs

@@ -5,14 +5,14 @@ namespace Yuuna.Contracts.Optimization
 
     internal struct Pair : IPair
     {
-        internal Pair(string key, ISynosym synosym)
+        internal Pair(string key, ISynonym synonym)
         {
             this.Key = key;
-            this.Synosym = synosym;
+            this.Synonym = synonym;
         }
 
         public string Key { get; }
-        public ISynosym Synosym { get; }
+        public ISynonym Synonym { get; }
     }
 
 }

src/Yuuna.Contracts/Optimization/Score.cs

@@ -17,7 +17,7 @@ namespace Yuuna.Contracts.Optimization
 
             this.IsCompacted = contrast.Count == matches.Count;
             this.Coverage = (double)matches.Count / contrast.Count;
-            this.Missing = contrast.ToImmutable().Except(matches.Select(x => x.Synosym.Owner)).ToImmutableArray();
+            this.Missing = contrast.ToImmutable().Except(matches.Select(x => x.Synonym.Owner)).ToImmutableArray();
         }
 
         public PluginBase Plugin { get; }

src/Yuuna.Contracts/Optimization/StrategyBase.cs

@@ -53,7 +53,7 @@ namespace Yuuna.Contracts.Optimization
                 iterator.MoveNext();
                 foreach (var word in words)
                 {
-                    if (iterator.Current.TryGetSynosym(word, out var s))
+                    if (iterator.Current.TryGetSynonym(word, out var s))
                     {
                         matches.Add(new Pair(s.Owner.Key, s));
                         if (!iterator.MoveNext())

src/Yuuna.Contracts/Semantics/IGroup.cs

@@ -19,25 +19,25 @@
         /// 嘗試使用交集取得同義詞物件。
         /// 若具有交集則將參數中的值附加至該搜尋到的同義詞物件中；若無，則透過參數建立新的同義詞實體並傳回。
         /// </summary> 
-        /// <param name="synosyms">待加入的同義詞清單。若此同義詞物件不包含任何與此清單相關的詞，則使用此參數建立新同義詞實體。</param>
+        /// <param name="synonyms">待加入的同義詞清單。若此同義詞物件不包含任何與此清單相關的詞，則使用此參數建立新同義詞實體。</param>
         /// <param name="stringComparer">字串比對器。</param>
         /// <returns></returns>
         /// <exception cref="ArgumentNullException"/>
-        ISynosym AppendOrCreate(IEnumerable<string> synosyms, StringComparer stringComparer = null);
+        ISynonym AppendOrCreate(IEnumerable<string> synonyms, StringComparer stringComparer = null);
 
 
         /// <summary>
         /// 嘗試取得同義詞物件。
         /// </summary>
         /// <param name="word">單詞。</param>
-        /// <param name="synosyms">同義詞。</param>
+        /// <param name="synonyms">同義詞。</param>
         /// <returns></returns>
-        bool TryGetSynosym(string word, out ISynosym synosyms);
+        bool TryGetSynonym(string word, out ISynonym synonyms);
 
         /// <summary>
         /// 轉換成不可變清單以使用 Linq 。
         /// </summary>
         /// <returns></returns>
-        IImmutableList<ISynosym> ToImmutable();
+        IImmutableList<ISynonym> ToImmutable();
     }
 }

src/Yuuna.Contracts/Semantics/ISynosym.cs

@@ -8,7 +8,7 @@ namespace Yuuna.Contracts.Semantics
     /// <summary>
     /// 同義詞物件
     /// </summary>
-    public interface ISynosym : IEquatable<IEnumerable<string>>, IEquatable<string>, IEquatable<ISynosym>
+    public interface ISynonym : IEquatable<IEnumerable<string>>, IEquatable<string>, IEquatable<ISynonym>
     {
         /// <summary>
         /// 表示該物件隸屬的群體。

src/Yuuna.Contracts/Synosym.cs → src/Yuuna.Contracts/Synonym.cs

@@ -10,7 +10,7 @@
         using System.Diagnostics;
         using System.Linq;
 
-        internal sealed class Synosym : ISynosym
+        internal sealed class Synonym : ISynonym
         {
             public bool Equals(IEnumerable<string> manyStrings)
             {
@@ -37,11 +37,11 @@
                 return this._set.Contains(word, this.StringComparer);
             }
 
-            public bool Equals(ISynosym synosym)
+            public bool Equals(ISynonym synonym)
             {
-                if (synosym is null)
+                if (synonym is null)
                     return false;
-                return this.Owner.Equals(synosym.Owner);
+                return this.Owner.Equals(synonym.Owner);
             }
 
             private readonly static StringComparer DefaultComparer = StringComparer.CurrentCultureIgnoreCase;
@@ -50,7 +50,7 @@
 
             private readonly HashSet<string> _set;
 
-            internal Synosym(Group owner, StringComparer stringComparer)
+            internal Synonym(Group owner, StringComparer stringComparer)
             {
                 this.StringComparer = stringComparer is null ? DefaultComparer : stringComparer;
                 this._set = new HashSet<string>(this.StringComparer);

src/Yuuna.Contracts/TextSegmention/JiebaSegmenter.cs

@@ -23,10 +23,10 @@ namespace Yuuna.Contracts.TextSegmention
             foreach (var name in manager.Keys)
             {
                 //Console.WriteLine(name);
-                foreach (var synosym in manager[name].ToImmutable())
+                foreach (var synonym in manager[name].ToImmutable())
                 {
-                    //Console.WriteLine("added: " + synosym.ToImmutable().Count);
-                    foreach (var w in synosym.ToImmutable())
+                    //Console.WriteLine("added: " + synonym.ToImmutable().Count);
+                    foreach (var w in synonym.ToImmutable())
                     {
                         //Console.WriteLine("added: " + w);
                         this._jieba.AddWord(w);