uCalc SDK Interactive Examples

A simple find-and-replace transformation to replace all occurrences of a word.

A simple find-and-replace transformation.

A simple inline function to convert inches to centimeters.

A simple Lexer/Tokenizer that categorizes content into numbers, operators, or keywords.

A simple LISP transpiler that handles only binary operators.

A simple lookup to find the index of the second occurrence of the word 'is'.

A simple lookup to retrieve a defined variable by its name and display its value.

A simple optional word.

A simple replacement demonstrating how to swap specific word patterns.

A simple two-pass transformation where the output of the first pass becomes the input for the second.

A simple word replacement to demonstrate the basic find-and-replace capability.

A single-pass transformer that converts headers, list items, bold, and italic Markdown syntax to HTML.

A succinct example demonstrating a simple chain of two replacement actions on the root string.

Adding an error handler callback

Adds a C-style single-line comment token and categorizes it as whitespace to be ignored by other rules.

Alias using symbol object

Alternative parts

An internal test to confirm that ErrorExpression returns an empty string for an error triggered manually by a user function during evaluation.

An internal test verifying that an expression remains tied to its original context, even after the context has been cloned and modified.

Applies `RewindOnChange` to a default rule set to enable complex, multi-rule transformations for a custom `Average` function.

ArgDbl (same as Arg)

Arrays with DefineVariable

Assigns descriptive text to multiple rules and uses the `Rule` property to identify which rule generated each match.

Attaches and retrieves a simple metadata description from a variable.

Automatic recalculation when a source cell is changed.

Basic data cleaning by trimming whitespace and changing the case of a single key-value pair.

Basic distinction between a root rule and a child rule.

Basic forward and turn commands (LOGO).

Basic Key-Value extraction using a colon as an anchor.

Basic round-trip from an item back to its parent instance.

BracketSensitive

Calculates a monthly loan payment by defining a custom function with the standard amortization formula, showcasing a practical, real-world use case.

Calculates a total price using predefined variables and demonstrates the effect of output formatting.

Calculates simple interest by defining variables and then evaluating an expression string that uses them.

Calculates simple interest using pre-defined variables for a real-world scenario.

Calculating a simple percentage for a real-world financial scenario.

Capturing both parsing-stage and evaluation-stage errors to see how ErrorLocation behaves differently.

CaseSensitive

Chains `Before` and `Replace` to modify only the scheme of a URL, demonstrating the live view concept.

Change characters accepted as alphanumeric in expressions using ExpressionTokens() & Token()

Change newline from statement separator to whitespace

Change newline from statement separator to whitespace using TypeOfToken

Changing accepted tokens with ItemOf().Regex or ExpressionTokens().Token

Changing an item's property

Changing the parent uCalc object for a Transformer

Checking if a uCalc object is the default with IsDefault

Checking the error code for a simple syntax error

Checking the error code for a simple syntax error using a callback.

Checking variable types against BuiltInType

Checks for the existence of a required header in a string.

Checks for the existence of a required header in a string.

Comprehensive demonstration of Count() across arrays, functions with different parameter types, and operators.

Converting a single line of legacy variable declaration syntax to a modern equivalent.

Converting from Celsius to Fahrenheit with the Transformer

Converting quoted strings into XML-style elements by stripping the original quotes.

Converting single-quoted strings to double-quoted ones by targeting the delimiters.

Core VB.NET idioms: `Using` for lifetime management, property syntax, and implicit string conversions.

Creates a custom `IIf` function to demonstrate basic lazy evaluation. The division-by-zero error in the unevaluated branch is safely ignored.

Creates a domain-specific currency conversion syntax using the ExpressionTransformer, the correct tool for multi-word patterns.

Creating a clone of a uCalc object