IncludeCPP 3.7.15__py3-none-any.whl → 3.7.16__py3-none-any.whl

includecpp/__init__.py

@@ -2,7 +2,7 @@ from .core.cpp_api import CppApi
 from .core import cssl_bridge as CSSL
 import warnings
 
-__version__ = "3.7.15"
+__version__ = "3.7.16"
 __all__ = ["CppApi", "CSSL"]
 
 # Module-level cache for C++ modules

includecpp/core/cssl/cssl_builtins.pyi

@@ -3,10 +3,10 @@ CSSL Built-in Functions - Complete Type Stubs & Documentation
 ==============================================================
 
 This file provides comprehensive type hints and documentation for all CSSL
-built-in functions and container types. All are available in CSSL scripts
-without imports.
+built-in functions, data types, and container types. All are available in
+CSSL scripts without imports.
 
-Total: 200+ functions + 9 container classes across 19 categories.
+Total: 200+ functions + 9 container classes + 10 data types across 20 categories.
 
 Categories:
     - Output Functions (7)
@@ -27,6 +27,7 @@ Categories:
     - Container Classes (9) - stack<T>, vector<T>, array<T>, map<K,V>, etc.
     - Function Keywords (10)
     - Classes & OOP
+    - Data Types (10) - int, float, string, bool, dynamic, var, list, dict, void, null
     - Special Syntax Reference
 
 Container Types with Methods (use lowercase names for quick lookup):
@@ -42,6 +43,20 @@ Container Types with Methods (use lowercase names for quick lookup):
 
 Type "vector." to see all available methods with documentation.
 
+Data Types (use type aliases for quick lookup):
+    - int_t: int - whole numbers
+    - float_t: float - decimal numbers
+    - string_t: string - text with interpolation
+    - bool_t: bool - true/false values
+    - dynamic_t: dynamic - any type (auto-typed)
+    - var_t: var - type inference
+    - list_t: list - ordered collection
+    - dict_t: dict - key-value pairs
+    - void_t: void - no return value
+    - null_t: null/None - absence of value
+
+Type "int_t" or "DataTypes." to see data type documentation.
+
 Usage from Python:
     from includecpp import CSSL
 
@@ -4151,6 +4166,365 @@ class SpecialSyntax:
         """
         ...
 
+# =============================================================================
+# DATA TYPES
+# =============================================================================
+
+class DataTypes:
+    """
+    CSSL Data Types Reference
+
+    CSSL supports various primitive and compound data types for variable
+    declarations and function parameters/returns.
+    """
+
+    def int_type(self) -> None:
+        """Integer type - whole numbers.
+
+        Range: Platform-dependent (typically 64-bit signed integer)
+
+        Example:
+            int x = 42;
+            int negative = -100;
+            int hex = 0xFF;          // Hexadecimal
+            int binary = 0b1010;     // Binary (if supported)
+
+            // Arithmetic
+            int sum = x + 10;
+            int product = x * 2;
+            int quotient = x / 5;
+            int remainder = x % 7;
+
+            // Increment/decrement
+            x++;
+            x--;
+        """
+        ...
+
+    def float_type(self) -> None:
+        """Floating-point type - decimal numbers.
+
+        Supports standard IEEE 754 double precision.
+
+        Example:
+            float pi = 3.14159;
+            float negative = -2.5;
+            float scientific = 1.5e10;   // 1.5 × 10^10
+
+            // Arithmetic
+            float result = pi * 2.0;
+            float divided = 10.0 / 3.0;  // 3.333...
+
+            // Conversion
+            int rounded = int(pi);       // 3
+            float fromInt = float(42);   // 42.0
+        """
+        ...
+
+    def string_type(self) -> None:
+        """String type - text sequences.
+
+        Supports single quotes, double quotes, and string interpolation.
+
+        Example:
+            string name = "Alice";
+            string alt = 'Bob';           // Single quotes work too
+
+            // String interpolation (f-string style)
+            string greeting = "Hello {name}!";     // "Hello Alice!"
+            string altStyle = "Hello <name>!";     // Also works
+
+            // Concatenation
+            string full = "Hello" + " " + "World";
+            string repeated = "ab" * 3;            // "ababab"
+
+            // Methods/functions
+            int length = len(name);                // 5
+            string upper = upper(name);            // "ALICE"
+            bool hasA = contains(name, "A");       // true
+
+            // Indexing
+            string first = name[0];                // "A"
+            string slice = substr(name, 0, 3);     // "Ali"
+        """
+        ...
+
+    def bool_type(self) -> None:
+        """Boolean type - true/false values.
+
+        Example:
+            bool isActive = true;
+            bool isComplete = false;
+
+            // Logical operations
+            bool and_result = true && false;       // false
+            bool or_result = true || false;        // true
+            bool not_result = !true;               // false
+
+            // Comparisons return bool
+            bool equal = (5 == 5);                 // true
+            bool greater = (10 > 5);               // true
+            bool notEqual = (3 != 4);              // true
+
+            // In conditions
+            if (isActive) {
+                printl("Active!");
+            }
+
+            // Ternary operator
+            string status = isActive ? "ON" : "OFF";
+        """
+        ...
+
+    def dynamic_type(self) -> None:
+        """Dynamic type - auto-typed, can hold any value.
+
+        Similar to Python's duck typing. Type is determined at assignment.
+        Can change type when reassigned.
+
+        Example:
+            dynamic x = 42;            // Currently int
+            printl(typeof(x));         // "int"
+
+            x = "hello";               // Now string
+            printl(typeof(x));         // "str"
+
+            x = [1, 2, 3];             // Now list
+            printl(typeof(x));         // "list"
+
+            // Useful for flexible functions
+            dynamic result = getData();  // Unknown return type
+
+            // Type checking
+            if (isint(x)) {
+                printl("It's a number!");
+            }
+        """
+        ...
+
+    def var_type(self) -> None:
+        """Var type - type inference from assigned value.
+
+        Type is inferred at assignment and remains fixed.
+        More constrained than 'dynamic'.
+
+        Example:
+            var count = 100;           // Inferred as int
+            var name = "Bob";          // Inferred as string
+            var items = [1, 2, 3];     // Inferred as list
+
+            // Type is determined by right-hand side
+            var result = calculate();  // Type of function return
+        """
+        ...
+
+    def list_type(self) -> None:
+        """List type - ordered collection of values.
+
+        Can contain mixed types. Zero-indexed.
+
+        Example:
+            // Declaration
+            list items = [1, 2, 3, 4, 5];
+            list mixed = ["hello", 42, true, 3.14];
+            list empty = [];
+
+            // Typed list (generic)
+            list<int> numbers = [1, 2, 3];
+            list<string> names = ["Alice", "Bob"];
+
+            // Access
+            int first = items[0];           // 1
+            int last = items[len(items)-1]; // 5
+
+            // Modification
+            push(items, 6);                 // Add to end
+            pop(items);                     // Remove from end
+            items[0] = 100;                 // Set by index
+
+            // Iteration
+            foreach (item in items) {
+                printl(item);
+            }
+
+            // Operations
+            int length = len(items);
+            bool hasValue = contains(items, 3);
+            list sorted = sort(items);
+            list reversed = reverse(items);
+            list slice = slice(items, 1, 3);
+        """
+        ...
+
+    def dict_type(self) -> None:
+        """Dictionary type - key-value pairs.
+
+        Keys are typically strings or integers. Values can be any type.
+        Also available as 'dictionary' keyword.
+
+        Example:
+            // Declaration
+            dict person = {
+                "name": "Alice",
+                "age": 30,
+                "active": true
+            };
+
+            // Access
+            string name = person["name"];       // "Alice"
+            int age = person["age"];            // 30
+
+            // Modification
+            person["email"] = "alice@example.com";
+            delkey(person, "active");
+
+            // Methods
+            list allKeys = keys(person);        // ["name", "age", "email"]
+            list allValues = values(person);    // ["Alice", 30, "alice@..."]
+            bool hasName = haskey(person, "name");  // true
+
+            // Iteration
+            foreach (key in keys(person)) {
+                printl(key + ": " + person[key]);
+            }
+
+            // Safe access with default
+            string value = getkey(person, "missing", "default");
+
+            // Typed dictionary
+            dictionary<string> data;
+            data["key"] = "value";
+        """
+        ...
+
+    def void_type(self) -> None:
+        """Void type - no return value.
+
+        Used for function declarations that don't return anything.
+
+        Example:
+            void sayHello() {
+                printl("Hello!");
+                // No return statement needed
+            }
+
+            void processData(int value) {
+                // Do something with value
+                // Returns nothing
+            }
+
+            // Calling
+            sayHello();
+        """
+        ...
+
+    def null_type(self) -> None:
+        """Null type - absence of value.
+
+        Represents no value or undefined state.
+        Can be used with 'null' or 'None'.
+
+        Example:
+            dynamic x = null;
+            var y = None;               // Same as null
+
+            // Null checking
+            if (x == null) {
+                printl("No value");
+            }
+
+            if (isnull(x)) {
+                printl("x is null");
+            }
+
+            // Default value pattern
+            string result = value != null ? value : "default";
+        """
+        ...
+
+
+# Data type aliases for direct lookup
+int_t = DataTypes.int_type
+"""int - Integer type for whole numbers.
+
+Example:
+    int count = 42;
+    int negative = -100;
+    count++;
+"""
+
+float_t = DataTypes.float_type
+"""float - Floating-point type for decimal numbers.
+
+Example:
+    float pi = 3.14159;
+    float result = 10.0 / 3.0;
+"""
+
+string_t = DataTypes.string_type
+"""string - Text type with interpolation support.
+
+Example:
+    string name = "Alice";
+    string msg = "Hello {name}!";
+"""
+
+bool_t = DataTypes.bool_type
+"""bool - Boolean true/false type.
+
+Example:
+    bool active = true;
+    bool done = false;
+"""
+
+dynamic_t = DataTypes.dynamic_type
+"""dynamic - Auto-typed, can hold any value type.
+
+Example:
+    dynamic x = 42;
+    x = "now a string";
+"""
+
+var_t = DataTypes.var_type
+"""var - Type inference from assigned value.
+
+Example:
+    var count = 100;     // Inferred as int
+    var name = "Bob";    // Inferred as string
+"""
+
+list_t = DataTypes.list_type
+"""list - Ordered collection of values.
+
+Example:
+    list items = [1, 2, 3];
+    list<string> names = ["Alice", "Bob"];
+"""
+
+dict_t = DataTypes.dict_type
+"""dict - Key-value pair collection.
+
+Example:
+    dict data = {"name": "Alice", "age": 30};
+    dict<string> config;
+"""
+
+void_t = DataTypes.void_type
+"""void - No return value (function declaration).
+
+Example:
+    void sayHello() { printl("Hello!"); }
+"""
+
+null_t = DataTypes.null_type
+"""null/None - Absence of value.
+
+Example:
+    dynamic x = null;
+    if (isnull(x)) { printl("No value"); }
+"""
+
+
 # =============================================================================
 # EXPORTS
 # =============================================================================
@@ -4215,4 +4589,7 @@ __all__ = [
     "stack", "vector", "array", "map", "datastruct", "iterator", "shuffled", "combo", "dataspace",
     # Syntax Reference Classes
     "FunctionKeywords", "ClassSyntax", "SpecialSyntax",
+    # Data Types Reference
+    "DataTypes", "int_t", "float_t", "string_t", "bool_t", "dynamic_t",
+    "var_t", "list_t", "dict_t", "void_t", "null_t",
 ]

{includecpp-3.7.15.dist-info → includecpp-3.7.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IncludeCPP
-Version: 3.7.15
+Version: 3.7.16
 Summary: Professional C++ Python bindings with type-generic templates, pystubs and native threading
 Home-page: https://github.com/liliassg/IncludeCPP
 Author: Lilias Hatterscheidt

{includecpp-3.7.15.dist-info → includecpp-3.7.16.dist-info}/RECORD

@@ -1,4 +1,4 @@
-includecpp/__init__.py,sha256=7I9GWPnH643fqiEgmBy5_bExUcouYIF0nPqz25Hldyo,1673
+includecpp/__init__.py,sha256=ePS4-92RVwu-pgbSjIZYIZ6k5yzXNb9j_eQmaehmadg,1673
 includecpp/__init__.pyi,sha256=uSDYlbqd2TinmrdepmE_zvN25jd3Co2cgyPzXgDpopM,7193
 includecpp/__main__.py,sha256=d6QK0PkvUe1ENofpmHRAg3bwNbZr8PiRscfI3-WRfVg,72
 includecpp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -22,7 +22,7 @@ includecpp/core/settings_ui.py,sha256=B2SlwgdplF2KiBk5UYf2l8Jjifjd0F-FmBP0DPsVCE
 includecpp/core/cssl/CSSL_DOCUMENTATION.md,sha256=47sUPO-FMq_8_CrJBZFoFBgSO3gSi5zoB1Xp7oeifho,40773
 includecpp/core/cssl/__init__.py,sha256=bMG8UO4eMfHEsyqp-wkiMLu-KERNcKUQF_s8yL8PLKU,1810
 includecpp/core/cssl/cssl_builtins.py,sha256=h9cN9GUn5jr8ed_xoXk-sturSSHtvBzffMLBBS3789I,85006
-includecpp/core/cssl/cssl_builtins.pyi,sha256=AJpJKNsRYUCciQ__bCtp5i4NyKDDifiGiCRMAlHp1tk,114254
+includecpp/core/cssl/cssl_builtins.pyi,sha256=MMy3NGUBGn8-4u4eUgf8wyENNMSmcFaiAd-icQbdbQE,124996
 includecpp/core/cssl/cssl_events.py,sha256=nupIcXW_Vjdud7zCU6hdwkQRQ0MujlPM7Tk2u7eDAiY,21013
 includecpp/core/cssl/cssl_modules.py,sha256=cUg0-zdymMnWWTsA_BUrW5dx4R04dHpKcUhm-Wfiwwo,103006
 includecpp/core/cssl/cssl_parser.py,sha256=t1C0fplyJz_ZqJOlfx5fG2GZZtCMJj4fCIgWzf-1JAY,113147
@@ -43,9 +43,9 @@ includecpp/vscode/cssl/images/cssl.png,sha256=BxAGsnfS0ZzzCvqV6Zb1OAJAZpDUoXlR86
 includecpp/vscode/cssl/images/cssl_pl.png,sha256=z4WMk7g6YCTbUUbSFk343BO6yi_OmNEVYkRenWGydwM,799
 includecpp/vscode/cssl/snippets/cssl.snippets.json,sha256=l4SCEPR3CsPxA8HIVLKYY__I979TfKzYWtH1KYIsboo,33062
 includecpp/vscode/cssl/syntaxes/cssl.tmLanguage.json,sha256=XKRLBOHlCqDDnGPvmNHDQPsIMR1UD9PBaJIlgZOiPqM,21173
-includecpp-3.7.15.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
-includecpp-3.7.15.dist-info/METADATA,sha256=vj7HSGJ_GwS07enOPua6Zk-0WQ_15WdpC83jBP8ZOQw,32122
-includecpp-3.7.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-includecpp-3.7.15.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
-includecpp-3.7.15.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
-includecpp-3.7.15.dist-info/RECORD,,
+includecpp-3.7.16.dist-info/licenses/LICENSE,sha256=fWCsGGsiWZir0UzDd20Hh-3wtRyk1zqUntvtVuAWhvc,1093
+includecpp-3.7.16.dist-info/METADATA,sha256=dLmld76znqXtp79rJbicPVPP1YxFctci8Fj0VySe3LM,32122
+includecpp-3.7.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+includecpp-3.7.16.dist-info/entry_points.txt,sha256=6A5Mif9gi0139Bf03W5plAb3wnAgbNaEVe1HJoGE-2o,59
+includecpp-3.7.16.dist-info/top_level.txt,sha256=RFUaR1KG-M6mCYwP6w4ydP5Cgc8yNbP78jxGAvyjMa8,11
+includecpp-3.7.16.dist-info/RECORD,,