Flee Wiki & Documentation Rss Feed

New Comment on "LanguageReference"

aph31 — Fri, 21 Dec 2012 08:58:28 GMT

Hi, is there possible for me to write a multiline expression? Example: This is vb format If a > 0 then If a <= 1 then X = b * ( a * 1.5 ) else X = ( 1.5 + ( a - 1 ) * 2 ) * b end if else X = 0 End if If y = 1 then X = X * 2 End if How to write this into expression without using custom function. because i write the formula in texbox, and it is impossible for me to write them to custom function.

New Comment on "GettingStarted"

0x69 — Wed, 13 Jun 2012 11:04:01 GMT

@bhrnjica For that you need custom functions and a bit of black magic: public static class CustomFunctions{ public static double isZero(double x) { return (x == 0.0) ? 1.0 : 0.0; } } class Program { static void Main(string[] args) { ExpressionContext context = new ExpressionContext(); IDynamicExpression eDynamic; double r1, r2; context.Imports.AddType(typeof(CustomFunctions)); context.Variables.Add("a1", 0.0); context.Variables.Add("a2", 0.0); eDynamic = context.CompileDynamic("isZero(a2)*1.0 + (1.0-isZero(a2))*(a1/(a2+isZero(a2)))"); context.Variables["a1"] = 1.0; // a2 zero context.Variables["a2"] = 0.0; r1 = (double)eDynamic.Evaluate(); // a2 not zero context.Variables["a2"] = 10.0; r2 = (double)eDynamic.Evaluate(); Console.WriteLine("{0}\n{1}", r1, r2); } }

New Comment on "GettingStarted"

0x69 — Tue, 12 Jun 2012 15:21:43 GMT

For that you need custom functions and a bit of black magic: public static class CustomFunctions{ public static double isZero(double x) { return (x == 0.0) ? 1.0 : 0.0; } } class Program { static void Main(string[] args) { ExpressionContext context = new ExpressionContext(); IDynamicExpression eDynamic; double result; context.Imports.AddType(typeof(CustomFunctions)); context.Variables["a1"] = 1.0; // a2 zero context.Variables["a2"] = 0.0; eDynamic = context.CompileDynamic("isZero(a2)*1.0 + (1.0-isZero(a2))*(a1/(a2+isZero(a2)))"); result = (double)eDynamic.Evaluate(); Console.WriteLine("{0}", result); // a2 not zero context.Variables["a2"] = 10.0; eDynamic = context.CompileDynamic("isZero(a2)*1.0 + (1.0-isZero(a2))*(a1/(a2+isZero(a2)))"); result = (double)eDynamic.Evaluate(); Console.WriteLine("{0}", result); } }

New Comment on "LanguageReference"

tiger2009 — Wed, 30 May 2012 05:02:13 GMT

This is very useful project , thanks.I don't know how to implement a switch,case structure with it. eg: switch(number) { case 0: number*3; case 1: return 5 case 2: return number*2 } Can we do it with flee if statements? Please help me.

New Comment on "ImportingTypes"

pulsarblow — Tue, 07 Feb 2012 20:20:21 GMT

@leithfx You could encapsulate your double in a custom type and exposed this type on the ExpressionOwner (as a Property or a method returning the instanciated type). This way you will be able to overload the == operator on your custom type and implement the custom behavior you are looking for.

New Comment on "Examples"

serhhio — Tue, 16 Aug 2011 10:07:56 GMT

this is good. By can I use this to filter some lists of objects like in the http://stackoverflow.com/q/7026855/185593 Or, may I use this code to compare with Enumeration values, like in http://stackoverflow.com/q/7075816/185593 ?

New Comment on "ImportingTypes"

leithfx — Thu, 07 Jul 2011 20:31:16 GMT

Is it possible to overload the = operator on doubles so that I can make it compare more loosely (i.e because of floating point precision, 1.1 + 2.2 doesnt equal 3.3). I would like to override the = operator to be more of an almost equals behaviour...

New Comment on "LanguageReference"

rocarnet — Tue, 22 Feb 2011 21:45:28 GMT

I am woking with your dll and I'm trying to evaluate the following expression, but it fails to compile:if(5 in (1 , 5) and 9 in (3 , 6 , 4) and 15 in (7 , 8) and 24 in (8 , 8) and 31 in (3, 3) ,"True","False") The problem is because the expression length. May you give some clue about it, in order to fix the problem.

Updated Wiki: LanguageReference

ECiloci — Thu, 18 Jun 2009 16:34:22 GMT

Language Reference

The expression language that Flee uses is a mix of elements of C# and VB.Net. Since the aim of this library is speed, the language is strongly typed (same rules as C#) and there is no late binding. Unlike C#, the language is not case-sensitive.

Contents

ArithmeticOperators
ComparisonOperators
AndOrXorNotOperators
ShiftOperators
Concatenation
Indexing
Literals
Casting
ConditionalOperator
InOperator
Overloaded Operators On Types

Arithmetic Operators
Flee supports all the standard arithmetic operators as well as the modulo (%) and power (^) operators.
Example: a*2 + b ^ 2 - 100 % 5

ComparisonOperators
All the comparison operators are supported as well. The not equal operator is <> and the equal operator is =
Example: a <> 100

And/Or/Xor/Not Operators
Flee uses these operators for both logical and bitwise operations. Since the expression language is strongly-typed, Flee can determine the types of the operands to these operators. If both operands are booleans, then the operation is logical. If both are integral, the operation is bitwise. Any other combination results in a compile error.
Example (logical): a > 100 And Not b = 100
Example (bitwise): (100 or 2) and 1

Shift Operators
The left (<<) and right (>>) shift operators do a bitwise shift and are only valid on integral types.
Example: 100 >> 2

Concatenation
The + operator also serves as the string concatenation operator. If either of its operands is a string, it will perform a concatenate instead of an addition. It is valid for only one operand to be a string in which case, both operands are converted to Object and formatted accordingly.
Example: "abc" + "def"
Example: "the number is: " + 100

Indexing
The indexing operator takes the form: member[indexExpression]. Any expression can appear inside the brackets. If the member being indexed is an array, Flee will emit optimized array element loading instructions. If the indexed member has a default indexer property, flee will call the property with the evaluated index. Indexing a type which is not an array and does not have a default indexer generates a compile exception.
Example: arr[i + 1] + 100

Literals
Flee supports the following literals in expressions:

Char - A character in single quotes: 'a'
Boolean - Either true or false
Real - Any number with a decimal point. You can use the 'd', 'f', or 'm' suffixes to specify whether the number should be stored in a double, single, or decimal respectively. Use the ExpressionOptions.RealLiteralDataType option to specify the data type used to store the number when no suffix is specified. The default is double.
Integral - Any number without a decimal point. Append "L" to force the number to a 64-bit integer and/or a "U" to force it to unsigned. Flee will try to assign an integer literal to the first integral type that can contain the value.
Hex - Integral constants can also be specified in hex notation: 0xFF12
String - String literals are enclosed in double quotes and escaping characters follows the same rules as C#: "string\u0021\r\n a \"new\" line"
Null - Using the keyword null will load the null reference into an expression.
DateTime - A valid .NET DateTime pattern surrounded by #'s. Use the ExpressionOptions.DateTimeFormat property to control the format. Example: #08/06/2008#.ToLongDateString()
TimeSpan - A string in the format ##[d.]hh:mm[:ss[.ff]]#. Example: #08/06/2008# + ##1.23:45#

Casting
Casting is performed using the special cast function which takes the form cast(value, type).
Example: 100 + cast(obj, int)

Conditional Operator
Flee supports a conditional operator that allows you to pick a result based on a boolean condition. It is implemented as a special function of the form if(condition, whenTrue, whenFalse). The operator is a "true" conditional operator: only the expression that matches the condition is evaluated.
Example: If(a > 100 and b > 10, "both greater", "less")

In Operator
The In operator is a boolean binary operator that returns true if its first operand is contained in its second operand. It has two forms

List: Searches a list of values for a given value: value IN (value1, value2, value3,...). The value is compared against each value in the list and true is returned if the value is found, false if no match is found.
Collection: Searches a single collection for a given value: value IN collection. The collection variable must implement ICollection<T>, IDictionary<K,V>, IList, or IDictionary for the expression to compile. Arrays can be searched with this operator as they implement the first interface.

Example (List): If(100 in (100, 200, 300, -1), "in", "not in")
Example (Collection): if(100 in collection, "in", "not in")

Overloaded Operators On Types
When evaluating an arithmetic, comparison, or conversion operation where the operands are not primitives, Flee will look for and use any overloaded operators defined on the operands. This means that you can create expressions such as a + b (where a and b are custom types), as long as there is an addition operator defined on either operand.

Updated Wiki: Home

ECiloci — Wed, 17 Jun 2009 17:23:32 GMT

Project Description
Flee is an expression parser and evaluator for the .NET framework. It allows you to compute the value of string expressions such as sqrt(a^2 + b^2) at runtime. It uses a custom compiler, strongly-typed expression language, and lightweight codegen to compile expressions directly to IL. This means that expression evaluation is extremely fast and efficient. Try out the demo, which lets you generate images based on expressions, and see for yourself.

Features

Fast and efficient expression evaluation
Small, lightweight library
Compiles expressions to IL using a custom compiler, lightweight codegen, and the DynamicMethod class
Expressions (and the IL generated for them) are garbage-collected when no longer used
Does not create any dynamic assemblies that stay in memory
Backed by a comprehensive suite of unit tests
Culture-sensitive decimal point
Fine-grained control of what types an expression can use
Supports all arithmetic operations including the power (^) operator
Supports string, char, boolean, and floating-point literals
Supports 32/64 bit, signed/unsigned, and hex integer literals
Features a true conditional operator
Supports short-circuited logical operations
Supports arithmetic, comparison, implicit, and explicit overloaded operators
Variables of any type can be dynamically defined and used in expressions
CalculationEngine: Reference other expressions in an expression and recalculate in natural order
Expressions can index arrays and collections, access fields and properties, and call functions on various types
Generated IL can be saved to an assembly and viewed with a disassembler

More information

Examples to learn how to create and evaluate expressions.
Language Reference for information on the expression language.
Frequently Asked Questions about using Flee.
Article on CodeProject for a more detailed overview.

License
Flee is licensed under the LGPL. This means that as long as you dynamically link (ie: add a reference) to the officially released assemblies, you can use it in commercial and non-commercial applications.

Updated Wiki: Home

ECiloci — Sat, 28 Mar 2009 23:29:56 GMT

Fast and efficient expression evaluation
Small, lightweight library
Compiles expressions to IL using a custom compiler, lightweight codegen, and the DynamicMethod class
Expressions (and the IL generated for them) are garbage-collected when no longer used
Does not create any dynamic assemblies that stay in memory
Backed by a comprehensive suite of unit tests
Culture-sensitive decimal point
Fine-grained control of what types an expression can use
Supports all arithmetic operations including the power (^) operator
Supports string, char, boolean, and floating-point literals
Supports 32/64 bit, signed/unsigned, and hex integer literals
Features a true conditional operator
Emits short-circuited logical operations
Supports arithmetic, comparison, implicit, and explicit overloaded operators
Variables of any type can be dynamically defined and used in expressions
CalculationEngine: Reference other expressions in an expression and recalculate in natural order
Expressions can index arrays and collections, access fields and properties, and call functions on various types
Generated IL can be saved to an assembly and viewed with a disassembler

More information

Examples to learn how to create and evaluate expressions.
Language Reference for information on the expression language.
Frequently Asked Questions about using Flee.
Article on CodeProject for a more detailed overview.

Updated Wiki: LanguageReference

ECiloci — Sat, 21 Mar 2009 18:33:36 GMT

ArithmeticOperators
ComparisonOperators
AndOrXorNotOperators
ShiftOperators
Concatenation
Indexing
Literals
Casting
ConditionalOperator
InOperator
Overloaded Operators On Types

Char - A character in single quotes: 'a'
Boolean - Either true or false
Real - Any number with a decimal point is treated as a double-precision floating-point number. Append a "f" to force the number to single-precision.
Integral - Any number without a decimal point. Append "L" to force the number to a 64-bit integer and/or a "U" to force it to unsigned. Flee will try to assign an integer literal to the first integral type that can contain the value.
Hex - Integral constants can also be specified in hex notation: 0xFF12
String - String literals are enclosed in double quotes and escaping characters follows the same rules as C#: "string\u0021\r\n a \"new\" line"
Null - Using the keyword null will load the null reference into an expression.
DateTime - A valid .NET DateTime pattern surrounded by #'s. Use the ExpressionOptions.DateTimeFormat property to control the format. Example: #08/06/2008#.ToLongDateString()
TimeSpan - A string in the format ##[d.]hh:mm[:ss[.ff]]#. Example: #08/06/2008# + ##1.23:45#

List: Searches a list of values for a given value: value IN (value1, value2, value3,...). The value is compared against each value in the list and true is returned if the value is found, false if no match is found.
Collection: Searches a single collection for a given value: value IN collection. The collection variable must implement ICollection<T>, IDictionary<K,V>, IList, or IDictionary for the expression to compile. Arrays can be searched with this operator as they implement the first interface.

Updated Wiki: ImportingTypes

ECiloci — Sat, 21 Mar 2009 18:24:59 GMT

Extending the functions available to an expression

Flee allows you to extend the functions available for use in its expressions. Because of Flee's design, you are not required to define adapter classes or use delegates. You simply define your functions in a class or use the functions of an existing class and Flee will do the rest. Note that reflection is only used to lookup the functions when the expression is compiled. When the expression is evaluated, the functions are called using IL instructions just like in a compiled assembly.

The following is a guide to the various ways to add custom functions to an expression:

Importing public, static functions

Define a class with all the public, static functions that you want to use:

public static class CustomFunctions
{
   public static int Product(int a, int b)
   {
      return a * b;
   }
 
   public static int Sum(int a, int b)
   {
      return a + b;
   }
}

Then use the Imports property of the ExpressionContext class to make them available for use in the expression:

ExpressionContext context = new ExpressionContext();
context.Imports.AddType(typeof(CustomFunctions));
context.Variables.Add("a", 100);
context.Variables.Add("b", 200);
 
IDynamicExpression e = context.CompileDynamic("product(a,b) + sum(a,b)");
int result = (int) e.Evaluate();

You can also import all the functions into a namespace:

context.Imports.AddType(typeof(CustomFunctions), "functions");
IDynamicExpression e = context.CompileDynamic("functions.product(a,b) + a - b");

This also works for the built-in .NET types:

ExpressionContext context = new ExpressionContext();
context.Imports.AddType(typeof(Math));
context.Variables.Add("a", 100);
 
IDynamicExpression e = context.CompileDynamic("cos(a)");
int result = (int) e.Evaluate();

Importing instance functions using variables

Since variables act as instances of their type, you can call any public, instance functions defined on them. Here's an example that demonstrates this:

ExpressionContext context = new ExpressionContext();
context.Variables.Add("rand", new Random());
 
IDynamicExpression e = context.CompileDynamic("rand.nextDouble() + 100");
double result = (double) e.Evaluate();

Importing function using an expression owner

When you attach an expression to an expression owner, you can use any public/non-public static/instance functions on the owner class. The only limitation is that the functions cannot be put in a separate namespace. Here's the previous example, using the Random class as the expression owner:

Random rand = new Random();
ExpressionContext context = new ExpressionContext(rand);
 
IDynamicExpression e = context.CompileDynamic("nextDouble() + 100");
double result = (double) e.Evaluate();

Type-safety

Flee performs type-checking on the return type and parameters of all imported functions and will throw an ExpressionCompileException if either is not valid in the context of the expression. Flee will also not allow calls to functions that do not return a value.

Updated Wiki: Home

ECiloci — Sat, 28 Feb 2009 19:44:50 GMT

Fast and efficient expression evaluation
Small, lightweight library
Compiles expressions to IL using a custom compiler, lightweight codegen, and the DynamicMethod class
Expressions (and the IL generated for them) are garbage-collected when no longer used
Does not create any dynamic assemblies that stay in memory
Backed by a comprehensive suite of unit tests
Culture-sensitive decimal point
Fine-grained control of what types an expression can use
Supports all arithmetic operations including the power (^) operator
Supports string, char, boolean, and floating-point literals
Supports 32/64 bit, signed/unsigned, and hex integer literals
Features a true conditional operator
Emits short-circuited logical operations
Supports arithmetic, comparison, implicit, and explicit overloaded operators
Variables of any type can be dynamically defined and used in expressions
CalculationEngine: Reference other expressions in an expression and recalculate in natural order
Expressions can index arrays and collections, access fields and properties, and call functions on various types
Generated IL can be saved to an assembly and viewed with a disassembler

More information

Examples to learn how to create and evaluate expressions.
Language Reference for information on the expression language.
Frequently Asked Questions about using Flee.
Article on CodeProject for a more detailed overview.

Updated Wiki: FAQ

ECiloci — Sat, 28 Feb 2009 19:43:20 GMT

Frequently Asked Questions

When I create an expression such as 1/2, why is the result 0 instead of 0.5?
When an arithmetic operation involves two integers, the result will be an integer. If either or both operands are floating-point, then the result will be floating-point. In the above case, since both operands are integers, an integer division is performed and yields 0. This is a performance feature which makes sure that expressions that perform arithmetic involving only integers will use the more efficient and faster integer instructions.

Workarounds:

Make either operand a real number: 1/2.0 or 1.0/2
Use the ExpressionOptions.IntegersAsDoubles option to force Flee to treat all integer literals as doubles. With this option set, 1/2 will evaluate to 0.5.

Why do I get compile exceptions when I call functions with multiple real number arguments and my culture uses ',' as the decimal separator (ie: sum(1,23, 4,56))?
When the decimal separator for real numbers is set to ',', Flee has to use a different character as the argument delimiter for functions otherwise the grammar becomes ambiguous. To avoid the ambiguity, Flee uses the list separator character from the parse culture as the delimiter for function arguments.

Example:
en-US: sum(1.23, 4.56)
fr-FR: sum(1,23; 4,56)

If you really want to use ',' for both the decimal separator and function arguments, you can set the ExpressionContext.ParserOptions.RequireDigitsBeforeDecimalPoint property to true. This will require all real numbers to have a digit before the decimal point (ie: 0.45 instead of .45) but will eliminate the grammar ambiguity.

Updated Wiki: CustomizingParser

ECiloci — Sat, 28 Feb 2009 19:34:55 GMT

Flee allows customization of its expression parser. Customizing the parser is done through the ExpressionContext.ParserOptions property. You set the properties to the values you want and then call RecreateParser to apply your changes.

Here's an example:

ExpressionContext context = new ExpressionContext();
context.Imports.AddType(typeof(Math))
 
context.CompileDynamic("max(1.23, 4.56)", context);
 
context.ParserOptions.DecimalSeparator = ',';
context.ParserOptions.FunctionArgumentSeparator = ';';
context.RecreateParser();
 
context.CompileDynamic("max(1,23; 4,56)", context);

Updated Wiki: Examples

ECiloci — Sat, 28 Feb 2009 19:25:58 GMT

Examples

This page contains links to code samples that demonstrate how to use Flee:

Getting started: Quick guide to evaluating expressions
Extending the functions available to an expression
Using Variables in expressions
Using Flee to evaluate boolean expressions
Using an expression owner
Using the calculation engine
Retrieving values from arrays and collections
Culture sensitive expressions
Customizing Flee's parser
Calling functions with a variable number of arguments

Updated Wiki: CalculationEngine

ECiloci — Sat, 28 Feb 2009 19:24:25 GMT

Using the Calculation Engine

The CalculationEngine allows you to create a network of expressions. The engine allows expressions to reference the results of other expressions in the engine, tracks dependencies, and recalculates in natural order.

// Create the calculation engine
CalculationEngine engine = new CalculationEngine();
ExpressionContext context = new ExpressionContext();
VariableCollection variables = context.Variables;
 
// Add some variables
variables.Add("x", 100);            
variables.Add("y", 200);
 
// Add an expression to the calculation engine as "a"
engine.Add("a", "x * 2", context);
 
// Add an expression to the engine as "b"
engine.Add("b", "y + 100", context);
            
// Add an expression at "c" that uses the results of "a" and "b"
engine.Add("c", "a + b", context);
            
// Get the value of "c"
int result = engine.GetResult<int>("c");
 
// Update a variable on the "a" expression            
variables["x"] = 200;
 
// Recalculate it
engine.Recalculate("a");
 
// Get the updated result
result = engine.GetResult<int>("c");

Another example

Here is an example project that shows how to use the CalculationEngine to implement a simple templating system. It reads a template file which has marked up tags such as Mr. <FullName>, you owe <Debt>. Once all the tags are loaded, it asks the user to enter an expression for each tag. Since we are using the calculation engine, the expression for each tag can reference the result of other tag expressions. Once all the expressions are entered, the CalculationEngine does a recalculate. The program then substitutes the result of each tag into the template and outputs the result.

Updated Wiki: LanguageReference

ECiloci — Thu, 12 Feb 2009 00:01:19 GMT

ArithmeticOperators
ComparisonOperators
AndOrXorNotOperators
ShiftOperators
Concatenation
Indexing
Literals
Casting
ConditionalOperator
InOperator
Overloaded Operators On Types

Char - A character in single quotes: 'a'
Boolean - Either true or false
Real - Any number with a decimal point is treated as a double-precision floating-point number. Append a "f" to force the number to single-precision.
Integral - Any number without a decimal point. Append "L" to force the number to a 64-bit integer and/or a "U" to force it to unsigned. Flee will try to assign an integer literal to the first integral type that can contain the value.
Hex - Integral constants can also be specified in hex notation: 0xFF12
String - String literals are enclosed in double quotes and escaping characters follows the same rules as C#: "string\u0021\r\n a \"new\" line"
Null - Using the keyword null will load the null reference into an expression.
DateTime - A valid .NET DateTime pattern surrounded by #'s. Use the ExpressionOptions.DateTimeFormat property to control the format. Example: #08/06/2008#.ToLongDateString()
TimeSpan - A string in the format ##[d.]hh:mm[:ss[.ff]]#. Example: #08/06/2008# + ##1.23:45#

List: Searches a list of values for a given value: value IN (value1, value2, value3,...). The value is compared against each value in the list and true is returned if the value is found, false if no match is found.
Collection: Searches a single collection for a given value: value IN collection. The collection variable must implement ICollection<T>, IDictionary<K,V>, IList, or IDictionary for the expression to compile. Arrays can be searched with this operator as they implement the first interface.

Updated Wiki: LanguageReference

ECiloci — Thu, 22 Jan 2009 03:30:34 GMT

ArithmeticOperators
ComparisonOperators
AndOrXorNotOperators
ShiftOperators
Concatenation
Indexing
Literals
Casting
ConditionalOperator
InOperator
Overloaded Operators On Types

Arithmetic Operators
Flee supports all the standard arithmetic operators as well as the modulo (%) and power (^) operators.
Example: a*2 + b ^ 2 - 100 % 5

ComparisonOperators
All the comparison operators are supported as well. The not equal operator is <> and the equal operator is =
Example: a <> 100

And/Or/Xor/Not Operators
Flee uses these operators for both logical and bitwise operations. Since the language is strongly-typed, Flee can determine the types of the operands to these operators. If both operands are booleans, then the operation is logical. If both are integral, the operation is bitwise. Any other combination results in a compile error.
Example (logical): a > 100 And Not b = 100
Example (bitwise): (100 or 2) and 1

Shift Operators
The left (<<) and right (>>) shift operators do a bitwise shift and are only valid on integral types.
Example: 100 >> 2

Concatenation
The + operator also serves as the string concatenation operator. If either of its operands is a string, it will perform a concatenate instead of an addition. It is valid for only one operand to be a string in which case, both operands are converted to Object and formatted accordingly.
Example: "abc" + "def"
Example: "the number is: " + 100

Indexing
The indexing operator takes the form: member[indexExpression]. Any expression can appear inside the brackets. If the member being indexed is an array, Flee will emit optimized array element loading instructions. If the indexed member has a default indexer property, flee will call the property with the evaluated index. Indexing a type which is not an array and does not have a default indexer generates a compile exception.
Example: arr[i + 1] + 100

Literals
Flee supports the following literals in expressions:

Char - A character in single quotes: 'a'
Boolean - Either true or false
Real - Any number with a decimal point is treated as a double-precision floating-point number. Append a "f" to force the number to single-precision.
Integral - Any number without a decimal point. Append "L" to force the number to a 64-bit integer and/or a "U" to force it to unsigned. Flee will try to assign an integer literal to the first integral type that can contain the value.
Hex - Integral constants can also be specified in hex notation: 0xFF12
String - String literals are enclosed in double quotes and escaping characters follows the same rules as C#: "string\u0021\r\n a \"new\" line"
Null - Using the keyword null will load the null reference into an expression.
DateTime - A valid .NET DateTime pattern surrounded by #'s. Use the ExpressionOptions.DateTimeFormat property to control the format. Example: #08/06/2008#.ToLongDateString()
TimeSpan - A string in the format ##[d.]hh:mm[:ss[.ff]]#. Example: #08/06/2008# + ##1.23:45#

Casting
Casting is performed using the special cast function which takes the form cast(value, type).
Example: 100 + cast(obj, int)

Conditional Operator
Flee supports a conditional operator that allows you to pick a result based on a boolean condition. It is implemented as a special function of the form if(condition, whenTrue, whenFalse). The operator is a "true" conditional operator; meaning it only evaluates the result that corresponds to the condition.
Example: If(a > 100 and b > 10, "both greater", "less")

In Operator
The In operator is a boolean binary operator that returns true if its first operand is contained in its second operand. It has two forms

List: Searches a list of values for a given value: value IN (value1, value2, value3,...). The value is compared against each value in the list and true is returned if the value is found, false if no match is found.
Collection: Searches a single collection for a given value: value IN collection. The collection variable must implement ICollection<T>, IDictionary<K,V>, IList, or IDictionary for the expression to compile. Arrays can be searched with this operator as they implement the first interface.

Example (List): If(100 in (100, 200, 300, -1), "in", "not in")
Example (Collection): if(100 in collection, "in", "not in")

Overloaded Operators On Types
When evaluating an arithmetic or comparison operation where the operands are not primitives, Flee will look for and use any overloaded operators defined on the operands. This means that you can create expressions such as a + b (where a and b are custom types), as long as there is an addition operator defined on either operand.