uCalc API Version: 2.1.3-preview.2 Released: 6/17/2026

Warning

uCalc API Preview Release Notice:The documentation describes the intended behavior of the API. The current preview build contains incomplete features, unoptimized performance, and is subject to breaking changes.

ReturnBool

Method

Product: 

Fast Math Parser

Class: 

Callback

Sets the boolean return value for a callback function.

Syntax

ReturnBool(bool)

Parameters

value
bool
The boolean value to be returned to the uCalc engine.

Return

void

This method does not return a value.

Remarks

The ReturnBool method is used within a callback function to send a boolean result back to the uCalc evaluation engine. It is the designated method for returning values from functions whose signatures are defined with As Bool.

When you create a custom function using DefineFunction and bind it to a native callback, the callback does not use a standard return statement to pass data back to uCalc. Instead, it uses the family of Return... methods on the uCalc.Callback object (cb). ReturnBool is the type-safe method for boolean values.

Type-Specific Returns

uCalc provides a specific return method for each primary data type to ensure type safety and clarity:

Using the correct method corresponding to the function's declared return type is crucial for predictable behavior.

💡 Comparative Analysis

In a native language like C# or C++, a function returns a value directly:

// Native C# functionbool IsPositive(int num) {    return num > 0;}

uCalc's callback mechanism acts as a bridge between the uCalc engine and your native code. The ReturnBool method is the tool you use to send a value across that bridge. It is not a direct language return but a command to the uCalc engine, telling it what the result of the callback's execution was.

This design allows for deep integration, enabling you to expose complex, high-performance native logic to the uCalc scripting environment in a controlled and type-aware manner.

Examples

Return and other type-specific versions of Return
				
					using uCalcSoftware;

var uc = new uCalc();

static void BooleanAnd(uCalc.Callback cb) {
   cb.ReturnBool(cb.ArgBool(1) && cb.ArgBool(2));
}
static void AddInt16(uCalc.Callback cb) {
   //C# promots Int16 to int for arithmetic hence (Int16) to convert it back
   cb.ReturnInt16((Int16)(cb.ArgInt16(1) + cb.ArgInt16(2)));

}
static void AddInt32(uCalc.Callback cb) {
   cb.ReturnInt32(cb.ArgInt32(1) + cb.ArgInt32(2));
}
static void AddInt64(uCalc.Callback cb) {
   cb.ReturnInt64(cb.ArgInt64(1) + cb.ArgInt64(2));
}


uc.DefineFunction("BooleanAnd(x As Bool, y As Bool) As Bool", BooleanAnd);
uc.DefineFunction("AddInt16(x As Int16, y As Int16) As Int16", AddInt16);
uc.DefineFunction("AddInt32(x As Int32, y As Int32) As Int32", AddInt32);
uc.DefineFunction("AddInt64(x As Int64, y As Int64) As Int64", AddInt64);

Console.WriteLine(uc.EvalStr("BooleanAnd(true, false)"));
Console.WriteLine(uc.EvalStr("AddInt16(5.2, 4.1)"));
Console.WriteLine(uc.EvalStr("AddInt32(2, 3)"));
Console.WriteLine(uc.EvalStr("AddInt64(10, 20)"));
				
			
false
9
5
30
				
					#include <iostream>
#include "uCalc.h"

using namespace std;
using namespace uCalcSoftware;

void ucalc_call BooleanAnd(uCalcBase::Callback cb) {
   cb.ReturnBool(cb.ArgBool(1) && cb.ArgBool(2));
}
void ucalc_call AddInt16(uCalcBase::Callback cb) {
   
   cb.ReturnInt16(cb.ArgInt16(1) + cb.ArgInt16(2));
}
void ucalc_call AddInt32(uCalcBase::Callback cb) {
   cb.ReturnInt32(cb.ArgInt32(1) + cb.ArgInt32(2));
}
void ucalc_call AddInt64(uCalcBase::Callback cb) {
   cb.ReturnInt64(cb.ArgInt64(1) + cb.ArgInt64(2));
}
int main() {
   uCalc uc;

   uc.DefineFunction("BooleanAnd(x As Bool, y As Bool) As Bool", BooleanAnd);
   uc.DefineFunction("AddInt16(x As Int16, y As Int16) As Int16", AddInt16);
   uc.DefineFunction("AddInt32(x As Int32, y As Int32) As Int32", AddInt32);
   uc.DefineFunction("AddInt64(x As Int64, y As Int64) As Int64", AddInt64);

   cout << uc.EvalStr("BooleanAnd(true, false)") << endl;
   cout << uc.EvalStr("AddInt16(5.2, 4.1)") << endl;
   cout << uc.EvalStr("AddInt32(2, 3)") << endl;
   cout << uc.EvalStr("AddInt64(10, 20)") << endl;
}
				
			
false
9
5
30
				
					Imports System
Imports uCalcSoftware
Public Module Program
   
   Public Sub BooleanAnd(ByVal cb As uCalc.Callback)
      cb.ReturnBool(cb.ArgBool(1) And cb.ArgBool(2))
   End Sub
   Public Sub AddInt16(ByVal cb As uCalc.Callback)
      
      cb.ReturnInt16(cb.ArgInt16(1) + cb.ArgInt16(2))
   End Sub
   Public Sub AddInt32(ByVal cb As uCalc.Callback)
      cb.ReturnInt32(cb.ArgInt32(1) + cb.ArgInt32(2))
   End Sub
   Public Sub AddInt64(ByVal cb As uCalc.Callback)
      cb.ReturnInt64(cb.ArgInt64(1) + cb.ArgInt64(2))
   End Sub
   Public Sub Main()
      Dim uc As New uCalc()
      
      uc.DefineFunction("BooleanAnd(x As Bool, y As Bool) As Bool", AddressOf BooleanAnd)
      uc.DefineFunction("AddInt16(x As Int16, y As Int16) As Int16", AddressOf AddInt16)
      uc.DefineFunction("AddInt32(x As Int32, y As Int32) As Int32", AddressOf AddInt32)
      uc.DefineFunction("AddInt64(x As Int64, y As Int64) As Int64", AddressOf AddInt64)
      
      Console.WriteLine(uc.EvalStr("BooleanAnd(true, false)"))
      Console.WriteLine(uc.EvalStr("AddInt16(5.2, 4.1)"))
      Console.WriteLine(uc.EvalStr("AddInt32(2, 3)"))
      Console.WriteLine(uc.EvalStr("AddInt64(10, 20)"))
   End Sub
End Module
				
			
false
9
5
30
Previous
Next