The Format() method allows you to intercept the output of functions like EvalStr and EvaluateStr and apply custom formatting transformations using a callback function. This creates a powerful, dynamic post-processing pipeline for all expression results.

Note: There are two versions of Format(). This one involves using a callback to a function in the host application for the formatting logic, while the other Format definition is done inline.

🎯 Targeting Specific Data Types

You can create formatters that apply globally or only to specific data types:

• Global Formatter: If you omit the targetDataTypeName and targetDataType parameters, the callback will be applied to the string result of all data types.
• Type-Specific Formatter: By providing a data type name (e.g., "Double") or a DataType object, you can restrict the formatter to run only when the expression result matches that type. This is ideal for scenarios like formatting numbers as currency, dates into a specific layout, or booleans as "Yes/No".

📚 Layering and Execution Order (The Format Stack)

uCalc maintains a separate formatting pipeline for each data type (plus one for global formatters). When you add multiple formatters, they are pushed onto a stack. The execution order is Last-In, First-Out (LIFO):

1. The most recently added formatter is executed first.
2. Its output is then passed as the input to the previously added formatter.
3. This continues until all applicable formatters in the stack have been processed.

This layering allows for building up complex formatting from simple, reusable components.

🗑️ Releasing Formats

This method returns an Item object. To remove the formatter from the pipeline, call uCalc.Item.Release on this item. This is crucial for temporary formatting rules to avoid memory leaks and unintended side effects.

Also, uCalc.EvalStr has a parameter that suppresses all formatting just for the given expression.

You can view all active formatters by using uc.ListOfItems(ItemIs.Format);.

🆚 Comparative Analysis

While languages like C# (string interpolation, String.Format) and Python (f-strings) provide excellent static formatting, uCalc's Format() method offers a different paradigm:

• Runtime Configuration: uCalc formatters are defined and layered at runtime. This allows an application to change its output style dynamically, perhaps based on user preferences or localization settings, without recompiling code.
• Decoupled Logic: The formatting logic is decoupled from the expression evaluation. You can define a complex calculation once and apply different formatting 'skins' to its output. This is highly effective for applications that need to present the same data in multiple ways (e.g., a report, a chart tooltip, a log file).
• Middleware Pipeline: The format stack acts like a middleware pipeline for strings, a concept more common in web frameworks. This is a uniquely powerful feature for a math parser, enabling sophisticated transformations that go far beyond simple value-to-string conversion.