uCalc SDK Interactive Examples

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Define the data context for our template
      uc.DefineVariable("user = 'Alice'")
      uc.DefineVariable("score = 95")
      
      '// Define the template with placeholders
      Dim myTemplate = "User: {user}, Score: {score * 10}, Status: {IIf(score > 90, 'Excellent', 'Good')}"
      
      Dim t = uc.NewTransformer()
      '// This single rule finds placeholders like {...}
      '// and uses the Expression Parser ({@@Eval}) to evaluate the content inside.
      t.FromTo("'{' {expr} '}'", "{@@Eval: expr}")
      
      Console.WriteLine(t.Transform(myTemplate))
      
   End Sub
End Module

Imports System&#13;Imports uCalcSoftware&#13;Public Module Program&#13;   Public Sub Main()&#13;      Dim uc As New uCalc()&#13;      Dim t = uc.NewTransformer()&#13;      '// Disable statement sensitivity to handle multi-line content&#13;      t.DefaultRuleSet.StatementSensitive = false&#13;      &#13;      Dim htmlContent =&#13;      "&#13;<nav>&#13;  <li><a href=""#intro"">Intro</a></li>&#13;  <!-- <li><a href=""#contact"">Contact</a></li> -->&#13;  <li><a href=""#about"">About</a></li>&#13;</nav>&#13;"&#13;      t.Text = htmlContent&#13;      &#13;      '// A rule to find all list items&#13;      t.Pattern("<li>{item}</li>")&#13;      &#13;      '// A rule to skip over HTML comments&#13;      t.SkipOver("<!-- {comment} -->")&#13;      &#13;      t.Find()&#13;      Console.WriteLine("--- Found List Items ---")&#13;      Console.WriteLine(t.Matches.Text)&#13;   End Sub&#13;End Module

Imports System
Imports uCalcSoftware
Public Module Program
   
   Public Sub URLDecode(ByVal cb As uCalc.Callback)
      '// In a real application, this would be a full URL decoding implementation.
      '// For this example, we'll just handle spaces (%20) and plus signs (+).
      Dim s As uCalc.String = cb.ArgStr(1)
      s.Replace("%20", " ").Replace("+", " ")
      cb.ReturnStr(s.Text)
   End Sub
   
   Public Sub Main()
      Dim uc As New uCalc()
      '// 1. Define the custom URLDecode function in the uCalc engine
      uc.DefineFunction("URLDecode(s As String) As String", AddressOf URLDecode)
      
      '// 2. Create the transformer and configure its tokenizer
      Using t As New uCalc.Transformer(uc)
         '// Treat '&' as a statement separator to process each pair individually
         t.Tokens.Add("&", TokenType.StatementSep)
         
         '// 3. Define the rule to capture key-value pairs and decode the value
         t.FromTo("{@Alphanumeric:key}={value}", "- {key}: '{@Eval: URLDecode(value)}'")
         
         '// 4. Process a real-world query string
         Dim queryString = "name=John%20Doe&role=user+admin&id=123"
         
         '// Use Filter() to get a clean, newline-separated list of the results
         Console.WriteLine(t.Transform(queryString).Matches)
      End Using
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Define a variable and chain the Description() call to set metadata
      Dim myVar = uc.DefineVariable("x = 10").SetDescription("Stores the current iteration count.")
      
      '// Retrieve and display the description
      Console.WriteLine($"Description for 'x': {myVar.Description}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      uc.DefineVariable("x = 10")
      uc.DefineFunction("DoubleThis(n) = n * 2")
      
      Console.WriteLine(uc.Eval("DoubleThis(x) + 5"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim x_var = uc.DefineVariable("x")
      Dim i = 0
      
      '// --- Inefficient Way ---
      Console.WriteLine("--- Inefficient: Eval() in a loop ---")
      For i  = 1 To 3
         x_var.Value(i)
         Console.WriteLine(uc.Eval("x * x + 2"))
      Next
      
      Console.WriteLine("")
      
      '// --- High-Performance Way ---
      Console.WriteLine("--- Efficient: Parse() once, Evaluate() in a loop ---")
      '// Parse outside the loop
      Dim expr = uc.Parse("x * x + 2")
      For i  = 1 To 3
         x_var.Value(i)
         '// Evaluate the pre-parsed object
         Console.WriteLine(expr.Evaluate())
      Next
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      '// This rule replaces the ALPHANUMERIC token 'get_data', not just the text.
      t.FromTo("get_data", "fetch_records")
      
      Dim code = "
// Note: 'get_data' is the old function name.
results = get_data(source);
print(""The 'get_data' function was called."");
"
      
      '// The default tokenizer recognizes the comment and string literal as separate tokens,
      '// so the rule to replace the function name doesn't affect them.
      Console.WriteLine(t.Transform(code))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   
   Public Sub DescribeArg(ByVal cb As uCalc.Callback)
      '// Retrieve the Item object for the first argument.
      Dim item = cb.ArgItem(1)
      
      '// Inspect the item's metadata.
      Dim name = item.Name
      If Len(name) = 0 Then
         name = "(literal)"
      End If
      
      Console.WriteLine($"  - Name: {name}, Type: {item.DataType.Name}")
   End Sub
   Public Sub Main()
      Dim uc As New uCalc()
      uc.DefineFunction("Describe(ByHandle arg As AnyType)", AddressOf DescribeArg)
      uc.DefineVariable("my_var = 100")
      
      Console.WriteLine("Inspecting a variable:")
      uc.Eval("Describe(my_var)")
      
      Console.WriteLine("Inspecting a literal value:")
      uc.Eval("Describe(123.45)")
      
      Console.WriteLine("Inspecting a string value:")
      uc.EvalStr("Describe('abc xyz')")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      t.Text = "apple banana apple cherry apple"
      
      '// Define a pattern to find any alphanumeric word
      t.Pattern("apple")
      t.Find()
      
      Console.WriteLine($"Found {t.Matches.Count()} occurrences of 'apple'.")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Console.WriteLine(uc.EvalStr("(37) * (9 / 5) + 32"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      '// RewindOnChange is necessary for cascading rules to be re-evaluated.
      t.FromTo("A", "B").RewindOnChange = true
      t.FromTo("B", "C").RewindOnChange = true
      t.FromTo("C", "D").RewindOnChange = true
      
      '// Trace the transformation of "A"
      Dim trace As uCalc.String = t.TraceTransform("A")
      
      '// Format the output list with ' -> ' for readability
      trace.ListSeparator(" -> ")
      
      Console.WriteLine(trace)
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// The implicit 'uc' object is not the default upon creation.
      Console.WriteLine($"Is 'uc' the default instance? {uc.IsDefault}")
      
      '// Create a new uCalc instance. It also won't be the default.
      Dim myCalc As New uCalc()
      Console.WriteLine($"Is 'myCalc' the default instance? {myCalc.IsDefault}")
      
      '// Let's get the actual default instance and check it.
      Dim defaultInstance As uCalc = uCalc.DefaultInstance
      Console.WriteLine($"Is the instance from uCalc.DefaultInstance the default? {defaultInstance.IsDefault}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t = uc.NewTransformer().SetText("The quick brown fox jumps over.")
      t.Pattern("fox")
      t.Find()
      
      Dim matches = t.Matches
      Console.WriteLine($"Original Start Position: {matches(0).StartPosition}")
      
      '// Add an offset of 100 to all match positions
      matches.ApplyOffset(100)
      
      Console.WriteLine($"New Start Position: {matches(0).StartPosition}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t1 As New uCalc.Transformer()
      Dim t2 As New uCalc.Transformer()
      
      '// Define a custom token in the first transformer
      Dim customToken = t1.Tokens.Add("###", TokenType.Generic)
      
      '// Import the token definition into the second transformer
      t2.Tokens.Add(customToken)
      t2.FromTo("###", "MATCH")
      
      Console.WriteLine($"t2 can now find '###': {t2.Transform("Test ### Test")}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      
      '// 1. Parent rule finds content inside parentheses.
      Dim parentRule = t.FromTo("({body})", "({body})")
      
      '// 2. Get the local transformer for the parent.
      Dim local_t = parentRule.LocalTransformer
      
      '// 3. Child rule runs only inside the parentheses.
      local_t.FromTo("this", "THIS")
      
      Dim text = "do not find this, but (find this) and not this"
      Console.WriteLine(t.Transform(text))
   End Sub
End Module

Imports System&#13;Imports uCalcSoftware&#13;Public Module Program&#13;   Public Sub Main()&#13;      Dim uc As New uCalc()&#13;      Dim t As New uCalc.Transformer()&#13;      &#13;      Dim rule1 = t.FromTo("Hello {name}", "Hi {name}")&#13;      Dim rule2 = t.Pattern("<h1>{title}</h1>")&#13;      &#13;      Console.WriteLine($"Rule 1 Name: '{rule1.Name}'")&#13;      Console.WriteLine($"Rule 2 Name: '{rule2.Name}'")&#13;   End Sub&#13;End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Console.WriteLine("Parsing the expression '100 / 4'...")
      Using parsedExpr As New uCalc.Expression("100 / 4")
         '//var parsedExpr = uc.Parse("100 / 4");
         
         Console.WriteLine("Evaluating the result...")
         Console.WriteLine($"Result: {parsedExpr.Evaluate()}")
      End Using
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim expr = uc.Parse("1 + 2")
      Console.WriteLine(expr.EvaluateStr())
      
      '// Manually release the expression when it's no longer needed.
      expr.Release()
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// 1. Parse the expression into a reusable object.
      Dim parsedExpr = uc.Parse("100 / 4")
      
      '// 2. Evaluate the pre-parsed object.
      Console.WriteLine($"Result: {parsedExpr.Evaluate()}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim myInt = uc.DefineVariable("myInt As Int")
      Dim myIntType = myInt.DataType
      Console.WriteLine($"Variable 'myInt' has type: {myIntType.Name}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Define a variable and retrieve its name from the Item object.
      Dim myVarItem = uc.DefineVariable("MyCoolVariable = 10")
      Console.WriteLine($"Item name: {myVarItem.Name}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      '// This rule only targets the alphanumeric token 'x'.
      t.FromTo("x", "value")
      Dim code = "x = 5; print(""The value of x is..."");"
      Console.WriteLine(t.Transform(code))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Console.WriteLine($"Square root of 81 is: {uc.Eval("Sqrt(81)")}")
      Console.WriteLine($"Is 10 greater than 5? {uc.EvalStr("IIf(10 > 5, 'Yes', 'No')")}")
      Console.WriteLine($"String length: {uc.Eval("Length('uCalc rocks!')")}")
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      '// Define a rule to find any number and wrap it in 'Num(...)'
      t.FromTo("{@Number:n}", "Num({n})")
      
      Console.WriteLine(t.Transform("var x = 10.5; var y = 20;"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Using s As New uCalc.String("This is just a test")
         
         '// Returns a view from 'just' to the end
         Dim result = s.StartingFrom("just")
         
         Console.WriteLine(result)
      End Using
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t = uc.NewTransformer()
      t.Text = "Config { setting = 123; }"
      
      '// 1. Define the parent rule to capture the content inside the braces.
      Dim parentRule = t.Pattern("Config '{' {body} '}'").SetStatementSensitive(false)
      
      '// 2. Get the local transformer for the parent rule.
      Dim local_t = parentRule.LocalTransformer
      
      '// 3. Define a rule that operates ONLY on the text captured by '{body}'.
      local_t.FromTo("setting = {val}", "Found Value: {val}")
      
      '// 4. Perform the transformation.
      '// The local rule will run on the text " setting = 123; ".
      t.Transform()
      
      Console.WriteLine(t.Text)
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Using s As New uCalc.String("The quick brown fox.")
         
         '// Replace returns the modified String object, but also modifies it in-place
         s.Replace("brown", "red")
         
         '// Use implicit conversion to print the result
         Console.WriteLine(s)
      End Using
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Using s As New uCalc.String("The quick brown fox.")
         
         '// Replace returns the modified String object
         s.Replace("brown", "red")
         
         '// Use implicit conversion to print the result
         Console.WriteLine(s)
      End Using
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      '// Get the transformer that pre-processes expressions.
      Dim t = uc.ExpressionTransformer
      
      '// Define a rule to find "X in to cm" and replace it with the calculated value.
      '// Note: 'val' is captured as text and must be converted to a number with Double().
      t.FromTo("{@Number:val} in to cm", "({@Eval: Double(val) * 2.54})")
      
      '// Use the new syntax directly in an expression.
      Console.WriteLine(uc.EvalStr("10 in to cm"))
   End Sub
End Module

Imports System
Imports uCalcSoftware
Public Module Program
   Public Sub Main()
      Dim uc As New uCalc()
      Dim t As New uCalc.Transformer()
      '// Define a simple replacement rule
      t.FromTo("Hello", "Greetings")
      
      '// Execute the transformation on an input string
      t.Text = "Hello World, and Hello again."
      Console.WriteLine(t.Transform())
   End Sub
End Module