Extension Property Calls for KatLang Code Readability
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
KatLang programming language lacks the ability to extend non-static objects with functionality from other non-static structures, limiting code readability and functionality due to the absence of user-defined static structures and applicable extension methods.
Innovation Solution
The introduction of 'extension property calls' allows accessing properties from other objects within the same visibility scope, enabling the use of regular properties as extension properties without special syntax, simplifying code and improving readability by allowing expressions to be written in the order they are executed.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If KatLang does not support user-defined static structures and extension methods, then the language maintains simplicity in its core structure, but the ability to extend non-static objects with functionality from other non-static structures is limited
Solution Approach 1:
The patent introduces an intermediary mechanism that allows non-static properties to be accessed on non-static objects without requiring static structures. The property access expression is translated into a property call expression, acting as a mediator between the object and the property, enabling extension functionality while maintaining the non-static nature of both objects and properties
Solution Approach 2:
Instead of requiring static structures to provide extension functionality (the conventional approach), the patent inverts the approach by allowing non-static properties to be accessed on non-static objects. This inversion enables extension capabilities while maintaining language simplicity and avoiding static structures
2Ease of operation
If property access syntax is used to access properties from other objects, then code readability is improved, but the syntax must be extended to allow accessing properties not contained in the object itself
Solution Approach 1:
The parser uses property visibility as an intermediary criterion to determine whether a property access expression should be interpreted as accessing a contained property or an extension property. This intermediary mechanism allows the parser to maintain simple syntax while enabling extended functionality through visibility checks
Solution Approach 2:
The property access expression is given universal functionality, serving both to access properties contained in the object and to access properties from other objects within the same visibility scope. This multi-functionality eliminates the need for separate syntax while improving code readability
3Ease of operation
If extension property calls are allowed without special syntax, then code conciseness is improved, but the language must allow accessing properties from any object within visibility scope
Solution Approach 1:
The patent applies local quality by restricting property accessibility to properties within the same visibility scope as the object. This ensures that extension property calls remain concise and intuitive while maintaining controlled accessibility, allowing the language to extend functionality without creating unrestricted access
Data Source
AI summary
In programming environments, an object can be extended by adding a new property (subroutine) to the collection of the object properties. The properties of the object can be accessed using property access syntax. Extension property call is an innovation which allows the use of an object together with property access expression to access the properties (subroutines) that are not contained in the object itself, but which are contained in another object and are visible in the scope where the property access expression is used. The extension properties do not have special extension property definition syntax. Any regular property (subroutine) can be used as the extension property of the object if the property is visible in the scope where the property access expression is used. Extension property calls makes programming language code concise, improving code readability.