Renamed semantics to intents; More compact logging

Author: Epixu

source/Code.cpp

@@ -21,16 +21,16 @@ LANGULUS_RTTI_BOUNDARY(RTTI::MainBoundary)
 #define ENABLE_VERBOSE() 0
 
 #define VERBOSE_INNER(...) \
-      Logger::Flow("Flow::Code: ", Logger::Push, Logger::Cyan, __VA_ARGS__ \
+      Logger::Flow("Flow::Code: ", Logger::PushCyan, __VA_ARGS__ \
          , Logger::Pop, " at ", progress, ": " \
-         , Logger::NewLine, "+-[", Logger::Push, Logger::Green, Logger::Underline \
-         , input. LeftOf(progress).Replace('\n', "\\n"), Logger::Pop, Logger::Push, Logger::White \
+         , Logger::NewLine, "+-[", Logger::PushGreen, Logger::Underline \
+         , input. LeftOf(progress).Replace('\n', "\\n"), Logger::PopAndPushWhite \
          , input.RightOf(progress).Replace('\n', "\\n"), Logger::Pop, ']')
 
 #define PRETTY_ERROR(...) { \
-      Logger::Error("Flow::Code: ", Logger::Push, Logger::DarkYellow, __VA_ARGS__ \
+      Logger::Error("Flow::Code: ", Logger::PushDarkYellow, __VA_ARGS__ \
          , Logger::Pop, " at ", progress, ": " \
-         , Logger::NewLine, "+-[", Logger::Push, Logger::DarkYellow, Logger::Underline \
+         , Logger::NewLine, "+-[", Logger::PushDarkYellow, Logger::Underline \
          , input. LeftOf(progress).Replace('\n', "\\n"), Logger::Pop \
          , input.RightOf(progress).Replace('\n', "\\n"), ']'); \
       LANGULUS_THROW(Flow, "Parse error"); \

source/Code.hpp

@@ -92,10 +92,10 @@ namespace Langulus::Flow
       ///                                                                     
       ///   Concatenation                                                     
       ///                                                                     
-      template<class T> requires CT::Codifiable<Desem<T>>
+      template<class T> requires CT::Codifiable<Deint<T>>
       NOD() Code operator + (T&&) const;
 
-      template<class T> requires CT::Codifiable<Desem<T>>
+      template<class T> requires CT::Codifiable<Deint<T>>
       Code& operator += (T&&);
 
       template<class T>

source/Code.inl

@@ -100,15 +100,15 @@ namespace Langulus::Flow
    /// Concatenate two text containers                                        
    ///   @param rhs - right hand side                                         
    ///   @return the concatenated text container                              
-   template<class T> requires CT::Codifiable<Desem<T>> LANGULUS(INLINED)
+   template<class T> requires CT::Codifiable<Deint<T>> LANGULUS(INLINED)
    Code Code::operator + (T&& rhs) const {
       return Text::ConcatInner<Code>(Forward<T>(rhs));
    }
 
    /// Concatenate (destructively) text containers                            
    ///   @param rhs - right hand side                                         
    ///   @return a reference to this container                                
-   template<class T> requires CT::Codifiable<Desem<T>> LANGULUS(INLINED)
+   template<class T> requires CT::Codifiable<Deint<T>> LANGULUS(INLINED)
    Code& Code::operator += (T&& rhs) {
       return Text::ConcatRelativeInner<Code>(Forward<T>(rhs));
    }

source/TFactory.hpp

@@ -125,8 +125,7 @@ namespace Langulus::Flow
       ProducedFrom(ProducedFrom&&);
       ProducedFrom(T* = nullptr, const Neat& = {});
 
-      template<template<class> class S>
-      requires CT::Semantic<S<Neat>>
+      template<template<class> class S> requires CT::Intent<S<Neat>>
       ProducedFrom(S<ProducedFrom>&&);
 
       void Detach();

source/TFactory.inl

@@ -250,10 +250,10 @@ namespace Langulus::Flow
    ProducedFrom<T>::ProducedFrom(ProducedFrom&& other)
       : ProducedFrom {Move(other)} {}
 
-   /// Semantic construction                                                  
-   ///   @param other - semantic and element to initialize with               
+   /// Generic construction                                                   
+   ///   @param other - intent and element to initialize with                 
    template<class T> template<template<class> class S>
-   requires CT::Semantic<S<Neat>> LANGULUS(INLINED)
+   requires CT::Intent<S<Neat>> LANGULUS(INLINED)
    ProducedFrom<T>::ProducedFrom(S<ProducedFrom<T>>&& other)
       // mProducer intentionally not overwritten                        
       : mDescriptor {S<Neat> {other->mDescriptor}} {}

source/TVerb.inl

@@ -27,7 +27,7 @@ namespace Langulus::Flow
       : Verb {Move(other)} {}
 
    /// Generic constructor                                                    
-   ///   @param other - the verb/argument and semantic to construct with      
+   ///   @param other - the verb/argument and intent to construct with        
    TEMPLATE() template<CT::Data T1, CT::Data...TN>
    requires CT::VerbMakable<T1, TN...> LANGULUS(INLINED)
    TME()::TVerb(T1&& t1, TN&&...tn)
@@ -205,7 +205,7 @@ namespace Langulus::Flow
 
    /// Push anything to end of the outputs, satisfying the verb               
    ///   @attention nullptrs are never pushed and don't satisfy verb          
-   ///   @param rhs - the data (and semantic) to push                         
+   ///   @param rhs - the data and intent to push                             
    ///   @return a reference to this verb for chaining                        
    TEMPLATE() LANGULUS(INLINED)
    VERB& TME()::operator << (CT::UnfoldInsertable auto&& rhs) {
@@ -215,25 +215,25 @@ namespace Langulus::Flow
 
    /// Push anything to the front of the outputs, satisfying the verb         
    ///   @attention nullptrs are never pushed and don't satisfy verb          
-   ///   @param rhs - the data (and semantic) to push                         
+   ///   @param rhs - the data and intent to push                             
    ///   @return a reference to this verb for chaining                        
    TEMPLATE() LANGULUS(INLINED)
    VERB& TME()::operator >> (CT::UnfoldInsertable auto&& rhs) {
       using T = Deref<decltype(rhs)>;
       return Verb::operator >> <VERB>(Forward<T>(rhs));
    }
 
-   /// Merge anything to output's back by a semantic                          
-   ///   @param rhs - the data (and semantic) to merge                        
+   /// Merge anything to output's back, with or without an intent             
+   ///   @param rhs - the data and intent to merge                            
    ///   @return a reference to this verb for chaining                        
    TEMPLATE() LANGULUS(INLINED)
    VERB& TME()::operator <<= (CT::UnfoldInsertable auto&& rhs) {
       using T = Deref<decltype(rhs)>;
       return Verb::operator <<= <VERB>(Forward<T>(rhs));
    }
 
-   /// Merge anything to output's front by a semantic                         
-   ///   @param rhs - the data (and semantic) to merge                        
+   /// Merge anything to output's front, with or without an intent            
+   ///   @param rhs - the data and intent to merge                            
    ///   @return a reference to this verb for chaining                        
    TEMPLATE() LANGULUS(INLINED)
    VERB& TME()::operator >>= (CT::UnfoldInsertable auto&& rhs) {

source/Verb.inl

@@ -15,17 +15,17 @@ namespace Langulus::Flow
 {
 
    /// Generic constructor                                                    
-   ///   @param other - the verb/argument and semantic to construct with      
+   ///   @param other - the verb/argument and intent to construct with        
    template<CT::Data T1, CT::Data...TN>
    requires CT::VerbMakable<T1, TN...> LANGULUS(INLINED)
    Verb::Verb(T1&& t1, TN&&...tn) {
       if constexpr (sizeof...(TN) == 0 and not CT::Array<T1>) {
-         using S = SemanticOf<decltype(t1)>;
+         using S = IntentOf<decltype(t1)>;
          using T = TypeOf<S>;
 
          if constexpr (CT::VerbBased<T>) {
             // Make sure the VMeta is initialized                       
-            (void) DesemCast(t1).GetVerb();
+            (void) DeintCast(t1).GetVerb();
             new (this) A::Verb {S::Nest(t1).template Forward<A::Verb>()};
          }
          else Many::operator = (Forward<T1>(t1));
@@ -34,16 +34,16 @@ namespace Langulus::Flow
    }
 
    /// Generic assignment                                                     
-   ///   @param rhs - the verb/argument and semantic to assign by             
+   ///   @param rhs - the verb/argument and intent to assign by               
    ///   @return a reference to this verb                                     
    LANGULUS(INLINED)
    Verb& Verb::operator = (CT::VerbAssignable auto&& rhs) {
-      using S = SemanticOf<decltype(rhs)>;
+      using S = IntentOf<decltype(rhs)>;
       using T = TypeOf<S>;
 
       if constexpr (CT::VerbBased<T>) {
          // Make sure the VMeta is initialized                          
-         (void) DesemCast(rhs).GetVerb();
+         (void) DeintCast(rhs).GetVerb();
          A::Verb::operator = (S::Nest(rhs).template Forward<A::Verb>());
       }
       else Many::operator = (S::Nest(rhs));
@@ -71,7 +71,7 @@ namespace Langulus::Flow
       CT::UnfoldInsertable auto&& a,
       const Charge& charge, VerbState state
    ) {
-      using S = SemanticOf<decltype(a)>;
+      using S = IntentOf<decltype(a)>;
       return FromMeta(MetaVerbOf<V>(), S::Nest(a), charge, state);
    }
 
@@ -86,7 +86,7 @@ namespace Langulus::Flow
       VMeta verb, CT::UnfoldInsertable auto&& a,
       const Charge& charge, VerbState state
    ) {
-      using S = SemanticOf<decltype(a)>;
+      using S = IntentOf<decltype(a)>;
       auto result = FromMeta(verb, charge, state);
       result.SetArgument(S::Nest(a));
       return result;
@@ -418,17 +418,17 @@ namespace Langulus::Flow
 
    /// Push anything to end of the outputs, satisfying the verb               
    ///   @attention nullptrs are never pushed and don't satisfy verb          
-   ///   @param rhs - the data (and semantic) to push                         
+   ///   @param rhs - the data and intent to push                             
    ///   @return a reference to this verb for chaining                        
    template<CT::VerbBased THIS> LANGULUS(INLINED)
    THIS& Verb::operator << (CT::UnfoldInsertable auto&& rhs) {
-      using S = SemanticOf<decltype(rhs)>;
+      using S = IntentOf<decltype(rhs)>;
       using T = TypeOf<S>;
 
       if constexpr (not CT::Nullptr<T>) {
          if constexpr (CT::PointerRelated<T>) {
             // Push a pointer only if valid                             
-            if (not DesemCast(rhs))
+            if (not DeintCast(rhs))
                return *reinterpret_cast<THIS*>(this);
          }
 
@@ -441,17 +441,17 @@ namespace Langulus::Flow
 
    /// Push anything to the front of the outputs, satisfying the verb         
    ///   @attention nullptrs are never pushed and don't satisfy verb          
-   ///   @param rhs - the data (and semantic) to push                         
+   ///   @param rhs - the data and intent to push                             
    ///   @return a reference to this verb for chaining                        
    template<CT::VerbBased THIS> LANGULUS(INLINED)
    THIS& Verb::operator >> (CT::UnfoldInsertable auto&& rhs) {
-      using S = SemanticOf<decltype(rhs)>;
+      using S = IntentOf<decltype(rhs)>;
       using T = TypeOf<S>;
 
       if constexpr (not CT::Nullptr<T>) {
          if constexpr (CT::PointerRelated<T>) {
             // Push a pointer only if valid                             
-            if (not DesemCast(rhs))
+            if (not DeintCast(rhs))
                return *reinterpret_cast<THIS*>(this);
          }
 
@@ -462,22 +462,22 @@ namespace Langulus::Flow
       return *reinterpret_cast<THIS*>(this);
    }
 
-   /// Merge anything to output's back by a semantic                          
-   ///   @param rhs - the data (and semantic) to merge                        
+   /// Merge anything to output's back, with or without an intent             
+   ///   @param rhs - the data and intent to merge                            
    ///   @return a reference to this verb for chaining                        
    template<CT::VerbBased THIS> LANGULUS(INLINED)
    THIS& Verb::operator <<= (CT::UnfoldInsertable auto&& rhs) {
-      using S = SemanticOf<decltype(rhs)>;
+      using S = IntentOf<decltype(rhs)>;
       using T = TypeOf<S>;
 
       if constexpr (not CT::Nullptr<T>) {
          if constexpr (CT::PointerRelated<TypeOf<S>>) {
             // Push a pointer, but check if valid first                 
-            if (not DesemCast(rhs))
+            if (not DeintCast(rhs))
                return *reinterpret_cast<THIS*>(this);
          }
 
-         auto ptr = PointerDecay(DesemCast(rhs));
+         auto ptr = PointerDecay(DeintCast(rhs));
          if (mOutput.Find(ptr))
             return *reinterpret_cast<THIS*>(this);
 
@@ -488,22 +488,22 @@ namespace Langulus::Flow
       return *reinterpret_cast<THIS*>(this);
    }
 
-   /// Merge anything to output's front by a semantic                         
-   ///   @param rhs - the data (and semantic) to merge                        
+   /// Merge anything to output's front, with or without an intent            
+   ///   @param rhs - the data and intent to merge                            
    ///   @return a reference to this verb for chaining                        
    template<CT::VerbBased THIS> LANGULUS(INLINED)
    THIS& Verb::operator >>= (CT::UnfoldInsertable auto&& rhs) {
-      using S = SemanticOf<decltype(rhs)>;
+      using S = IntentOf<decltype(rhs)>;
       using T = TypeOf<S>;
 
       if constexpr (not CT::Nullptr<T>) {
          if constexpr (CT::PointerRelated<TypeOf<S>>) {
             // Push a pointer, but check if valid first                 
-            if (not DesemCast(rhs))
+            if (not DeintCast(rhs))
                return *reinterpret_cast<THIS*>(this);
          }
 
-         auto ptr = PointerDecay(DesemCast(rhs));
+         auto ptr = PointerDecay(DeintCast(rhs));
          if (mOutput.Find(ptr))
             return *reinterpret_cast<THIS*>(this);
 

source/verbs/Associate.inl

@@ -84,7 +84,7 @@ namespace Langulus::Verbs
       // Attempt directly refering, if possible                         
       // This will happen only if types are exactly the same            
       // This is a default (fallback) routine, let's keep things simple 
-      try { lhs.AssignSemantic(Refer(rhs)); }
+      try { lhs.AssignWithIntent(Refer(rhs)); }
       catch (...) { return false; }
 
       // At this point, context has a copy of verb's argument           

source/verbs/Do.inl

@@ -85,8 +85,8 @@ namespace Langulus::Verbs
    ///   @param verb - the verb/flow to execute                               
    ///   @return the Do verb                                                  
    inline Do Do::In(auto&& context, auto&& verb) {
-      using CS = SemanticOf<decltype(context)>;
-      using VS = SemanticOf<decltype(verb)>;
+      using CS = IntentOf<decltype(context)>;
+      using VS = IntentOf<decltype(verb)>;
       Do v = VS::Nest(verb);
       v.SetSource(CS::Nest(context));
       return Abandon(v);