IncludeCPP 3.7.1__py3-none-any.whl → 3.7.25__py3-none-any.whl

includecpp/core/cssl/cssl_syntax.py

@@ -1,7 +1,7 @@
 """
 CSSL Syntax Highlighting
 
-Provides syntax highlighting for CSSL (CSO Service Script Language) code.
+Provides syntax highlighting for CSSL code.
 Can be used with:
 - PyQt5/6 QSyntaxHighlighter
 - VSCode/TextMate grammar export
@@ -216,8 +216,8 @@ class CSSLSyntaxRules:
 class ColorScheme:
     """Color scheme for syntax highlighting"""
 
-    # CSO Theme (Orange accent, dark background)
-    CSO_THEME = {
+    # CSSL Theme (Orange accent, dark background)
+    CSSL_THEME = {
         TokenCategory.KEYWORD: '#508cff',      # Blue
         TokenCategory.BUILTIN: '#ff8c00',      # Orange
         TokenCategory.OPERATOR: '#c8c8d2',     # Light gray
@@ -261,13 +261,13 @@ def highlight_cssl(source: str, scheme: Dict[TokenCategory, str] = None) -> List
 
     Args:
         source: CSSL source code
-        scheme: Color scheme dict (defaults to CSO_THEME)
+        scheme: Color scheme dict (defaults to CSSL_THEME)
 
     Returns:
         List of (start, end, color, category) tuples
     """
     if scheme is None:
-        scheme = ColorScheme.CSO_THEME
+        scheme = ColorScheme.CSSL_THEME
 
     highlights = []
     rules = CSSLSyntaxRules.get_rules()
@@ -337,7 +337,7 @@ def highlight_cssl_ansi(source: str) -> str:
     }
     RESET = '\033[0m'
 
-    highlights = highlight_cssl(source, ColorScheme.CSO_THEME)
+    highlights = highlight_cssl(source, ColorScheme.CSSL_THEME)
 
     # Build highlighted string
     result = []
@@ -388,7 +388,7 @@ def get_pyqt_highlighter():
 
         def _setup_rules(self):
             """Setup highlighting rules"""
-            scheme = ColorScheme.CSO_THEME
+            scheme = ColorScheme.CSSL_THEME
 
             for rule in CSSLSyntaxRules.get_rules():
                 fmt = QTextCharFormat()

includecpp/core/cssl/cssl_types.py

@@ -1,5 +1,5 @@
 """
-CSSL Data Types - Advanced container types for CSO Service Script Language
+CSSL Data Types - Advanced container types for CSSL
 
 Types:
 - datastruct<T>: Universal container (lazy declarator) - can hold any type
@@ -64,6 +64,33 @@ class DataStruct(list):
             return target_type(self[0])
         return None
 
+    def length(self) -> int:
+        """Return datastruct length"""
+        return len(self)
+
+    def size(self) -> int:
+        """Return datastruct size (alias for length)"""
+        return len(self)
+
+    def push(self, item: Any) -> 'DataStruct':
+        """Push item to datastruct (alias for add)"""
+        self.append(item)
+        return self
+
+    def isEmpty(self) -> bool:
+        """Check if datastruct is empty"""
+        return len(self) == 0
+
+    def contains(self, item: Any) -> bool:
+        """Check if datastruct contains item"""
+        return item in self
+
+    def at(self, index: int) -> Any:
+        """Get item at index (safe access)"""
+        if 0 <= index < len(self):
+            return self[index]
+        return None
+
     def begin(self) -> int:
         """Return iterator to beginning (C++ style)"""
         return 0
@@ -99,6 +126,16 @@ class Stack(list):
         self.append(item)
         return self
 
+    def pop(self) -> Any:
+        """Pop and return top element from stack"""
+        if len(self) == 0:
+            return None
+        return super().pop()
+
+    def pop_back(self) -> Any:
+        """Pop and return top element (alias for pop)"""
+        return self.pop()
+
     def peek(self) -> Any:
         """View top item without removing"""
         return self[-1] if self else None
@@ -701,6 +738,39 @@ class List(list):
             self.extend([value] * count)
         return self
 
+    def map(self, func: Callable[[Any], Any]) -> 'List':
+        """Apply function to all elements"""
+        result = List(self._element_type)
+        result.extend(func(item) for item in self)
+        return result
+
+    def filter(self, predicate: Callable[[Any], bool]) -> 'List':
+        """Filter elements by predicate"""
+        result = List(self._element_type)
+        result.extend(item for item in self if predicate(item))
+        return result
+
+    def forEach(self, func: Callable[[Any], None]) -> 'List':
+        """Execute function for each element"""
+        for item in self:
+            func(item)
+        return self
+
+    def reduce(self, func: Callable[[Any, Any], Any], initial: Any = None) -> Any:
+        """Reduce list to single value"""
+        from functools import reduce as py_reduce
+        if initial is None:
+            return py_reduce(func, self)
+        return py_reduce(func, self, initial)
+
+    def every(self, predicate: Callable[[Any], bool]) -> bool:
+        """Check if all elements match predicate"""
+        return all(predicate(item) for item in self)
+
+    def some(self, predicate: Callable[[Any], bool]) -> bool:
+        """Check if any element matches predicate"""
+        return any(predicate(item) for item in self)
+
     def begin(self) -> int:
         """Return iterator to beginning"""
         return 0
@@ -1499,7 +1569,10 @@ class CSSLInstance:
                 object.__setattr__(self, name, value)
 
     def __repr__(self):
-        return f"<CSSLInstance of '{self._class.name}'>"
+        return f"<{self._class.name} instance at 0x{id(self):x}>"
+
+    def __str__(self):
+        return f"<{self._class.name} instance at 0x{id(self):x}>"
 
 
 __all__ = [