Softanza Regexuter: Regex as Computational Reactive Medium

The stzRegexuter class extends traditional pattern matching into a sophisticated system for reactive computational processing. It transforms conventional regex operations into a dynamic, context-aware framework that enables immediate data transformation and state management.

The Foundation of Reactive Pattern Computation

The stzRegexuter, (the metaphor we embraced for our cutting-edge programmatic Regex Computer) implements a system where pattern matching directly triggers computational transformations. This approach enables immediate processing of matched patterns within their discovery context:

load "stzlib.ring"

rxu = new stzRegexuter()
rxu {
    # Define the pattern trigger
    AddTrigger(:NumberFound = "(\d+)")

    # Specify the computational transformation
    AddComputation(
        :When = :NumberFound,
        :Do = '{
            @value = @number(@value) * 2
        }'
    )

    result = Process("Found 42 items")
    ? @@(result)  
    #--> [
    #      [ "matches", [ "42" ] ],
    #      [ "results", [ 84 ] ]
    #    ]
}

In this example, numeric patterns are automatically processed and transformed according to specified rules.

Coordinated Multi-Pattern Processing

The stzRegexuter excels at managing multiple concurrent pattern operations, each with its own transformation logic:

NOTE: We can use directly rxu() small function as a shorthand for creating a stzRegexuter instance.

rxu() {
    # Define multiple pattern triggers
    Trigger(:Price = "\$(\d+\.?\d*)")
    Trigger(:Date = "(\d{2}/\d{2}/\d{4})")
    Trigger(:Email = "([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})")

    # Specify transformations for each pattern
    @C(:When = :Price, :Do = '{ @value = @number(@value) * 1.1 }')  # Tax calculation
    @C(:When = :Date, :Do = '{ @value = StandardizeDate(@value) }')  # Date normalization
    @C(:When = :Email, :Do = '{ @value = "CONTACT: " + @value }')    # Contact annotation

    text = "Order placed on 12/25/2023 for $99.99 by user@example.com"
    result = Process(text)
    ? @@(result)
    #--> [
    #      [ "matches", [ "$99.99", "12/25/2023", "user@example.com" ] ],
    #      [ "results", [ 109.89, "2023-12-25", "CONTACT: user@example.com" ] ]
    #    ]
}

This demonstrates simultaneous processing of prices, dates, and contact information within a single execution context.

State Management in Pattern Processing

The stzRegexuter implements pattern matching with state tracking, which is useful for various debugging and analytics scenarios, particularly in sensitive data handling and process verification. Consider this example:

rxu() {
    # Define sensitive data pattern processor
    Trigger(:SensitiveData = "(password|secret|key):\s*(\w+)")
    
    # Define transformation with logging
    @C(:When = :SensitiveData, :Do = '{
        originalLength = len(@value)
        @value = "REDACTED-" + originalLength
    }')

    # Process sensitive content
    Process("User credentials: password: abc123 secret: def456")
    
    ? @@NL(State())
    #--> [
    #    [ "sensitivedata", [ "password: abc123", "REDACTED-16" ] ],
    #    [ "sensitivedata", [ "secret: def456", "REDACTED-14" ] ]
    #    ]
}

This state tracking approach demonstrates redaction - a security practice where sensitive information is deliberately obscured while maintaining useful metadata. The "-16" and "-14" suffixes indicate original string lengths, enabling data structure preservation and validation without exposing sensitive content.

Advanced Features and Extensions

Softanza builds on its innovative stzRegexuter as a cornerstone of an advanced regex ecosystem, incorporating several specialized classes for enhanced pattern processing, namely: stzRegexAnalyzer, stzGeneticRegexuter, stzLinguisticRegexuter, and stzQuanticRegexuter.

Pattern Analysis with stzRegexAnalyser

Pattern optimization can be challenging, especially with complex expressions. The stzRegexAnalyser, a class inheriting from stzRegexuter, addresses this by providing concrete metrics about pattern performance, matching efficiency, and resource usage.

Take this simple example that shows how stzRegexAnalyzer helps developers optimize pattern matching performance through detailed analytics.:

rxAnalyser = new stzRegexAnalyser()
rxAnalyser {
    EnableMetrics(:For = "(\d+)")
    
    Process("Large dataset: 42, 123, 789, 1024")
    
    ? @@(Stats())
    #--> {
    #      matches: 4,
    #      complexity: 0.3,
    #      avgMatchTime: 0.002,
    #      recommendedOptimization: "Combine numeric patterns"
    #    }
}

Pattern Evolution with stzGeneticRegexuter

The genetic approach to pattern evolution solves a fundamental challenge in pattern matching: finding the most efficient pattern for varying data contexts. By treating patterns as evolving entities, stzGeneticRegexuter, a class inheriting from stzRegexuter, can automatically discover optimal patterns that human programmers might miss.

Here is a pratical prototype of how genetic programming paradigm works in the context of regex computing, by imporoving pattern matching performance hrough iterative optimization:

rxGenetic = new stzGeneticRegexuter()
rxGenetic {
    DefinePatternPopulation([
        "(\d+)",
        "(\d{1,3})",
        "([0-9]+)"
    ])

    result = EvolvePatterns(
        generations: 10, 
        criteria: { matchCoverage * 0.6 + processingEfficiency * 0.4 }
    )
    
    ? @@(result)
    #--> {
    #      bestPattern: "(\d{1,3})",
    #      fitnessScore: 0.85,
    #      evolutionPath: [ ... ]
    #    }
}

In practice, this is particularly valuable in adaptive systems like spam filters, content categorization, and dynamic data validation where patterns need to evolve with changing data characteristics.

Semantic Processing with stzLinguisticRegexuter

Natural language understanding requires more than simple pattern matching - it needs semantic awareness. stzLinguisticRegexuter, a class inheriting from stzRegexuter, bridges this gap by combining traditional pattern matching with linguistic analysis.

Let's see it by code through this example:

rxLing = new stzLinguisticRegexuter()
rxLing {
    AddLinguisticPattern(:SubjectAction = "(\w+)\s+(is|was|will)\s+(\w+)")
    
    @C(:When = :SubjectAction, :Do = '{
        AnalyzeSentenceSemantics(@value)
    }')

    result = Process("John will become a leader")
    ? @@(result)
    #--> {
    #      semanticStructure: {
    #        subject: "John",
    #        action: "will become",
    #        object: "leader",
    #        tense: "future"
    #      }
    #    }
}

In practice, This makes it especially powerful for applications like chatbots, document analysis, and automated content summarization where understanding context and meaning is as important as recognizing patterns.

Simultaneous Pattern Evaluation with stzQuanticRegexuter

stzQuanticRegexuter, a class inheriting from stzRegexuter, solves a common challenge in pattern matching: the need to evaluate multiple potential interpretations at once. Just as quantum computing can process multiple states simultaneously, this classs enables parallel pattern matching for more efficient text analysis.

Here is how it works:

rxQuantic = new stzQuanticRegexuter()
rxQuantic {
    # Define a pattern that can exist in multiple states
    AddQuantumPattern(:Greeting = "(?q:(hello|hi|hey))\s+(\w+)")
    
    # Process all possible interpretations simultaneously
    @C(:When = :Greeting, :Do = '{
        @qvalue = QuantumEvaluate(@value, {
            formal: HasFormalContext(@value),
            casual: HasCasualContext(@value)
        })
    }')

    result = ProcessQuantum("hello John")
    ? @@(result)
    #--> {
    #      matches: {
    #        [ "hello John", {
    #          formal: 0.8,    # High probability of formal context
    #          casual: 0.3     # Lower probability of casual context
    #        } ]
    #      },
    #      processingTime: 0.002
    #    }
}

This quantic-based approach for pattern matching is particularly valuable when working with: - Natural language processing, where words can have multiple meanings - Pattern matching that requires context awareness - Scenarios where multiple valid interpretations need to be ranked

NOTE: These classes are still in an early prototype phase and are not yet included in the library codebase. I have documented them here to illustrate the vision and the exciting roadmap for building on the strengths of the stzRegexuter class. stzRegexuter, however, is fully available, tested, and well integrated with other working classes in the Softanza regex framework, primarily stzRegex, stzRegexData, and stzRegexMaker.

Conclusion

The stzRegexuter represents a significant advancement in pattern matching technology, extending traditional regex capabilities with reactive computation, state management, and specialized processing modules. It provides a robust foundation for complex pattern-based data processing applications.

Lectures liées

• "Code Meets Cells": The Spreadsheet Metaphor in Softanza's stzTable

Citer

Mansour Ayouni. « Softanza Regexuter: Regex as Computational Reactive Medium ». Softanza narrations, 2025. https://mayouni.github.io/stzsite/fr/narrations/stzregexuter-regex-as-computational-reactive-medium.html

Non exécuté : son code ne se charge pas tel qu'il est écrit. L'article est publié tel qu'il est écrit ; ses blocs sont des illustrations. Le code des articles est du code Haro. Là où un article a été écrit avant que la langue prenne son nom actuel, le nom a été changé et rien d'autre. Genre, domaine et série lus dans le nom du fichier, année tirée du premier commit : dérivés, jusqu'à ce que l'article porte son propre en-tête. Le fichier sur GitHub(s'ouvre dans un nouvel onglet)