{"id":15130448,"url":"https://github.com/dadhi/fastexpressioncompiler","last_synced_at":"2025-05-13T15:11:35.815Z","repository":{"id":38858343,"uuid":"63421083","full_name":"dadhi/FastExpressionCompiler","owner":"dadhi","description":"Fast Compiler for C# Expression Trees and the lightweight LightExpression alternative. Diagnostic and code generation tools for the expressions.","archived":false,"fork":false,"pushed_at":"2025-05-08T14:21:12.000Z","size":9811,"stargazers_count":1265,"open_issues_count":30,"forks_count":88,"subscribers_count":35,"default_branch":"master","last_synced_at":"2025-05-08T15:28:45.137Z","etag":null,"topics":["benchmark","closure","code-generation","compiler","delegate","delegates","dryioc","expression-tree","il-optimizations","performance"],"latest_commit_sha":null,"homepage":"","language":"C#","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/dadhi.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":".github/FUNDING.yml","license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null},"funding":{"github":"dadhi"}},"created_at":"2016-07-15T12:44:20.000Z","updated_at":"2025-05-05T19:06:20.000Z","dependencies_parsed_at":"2024-01-05T20:52:51.816Z","dependency_job_id":"d35e70db-d5e3-4ca3-8f83-c5dceecad7fc","html_url":"https://github.com/dadhi/FastExpressionCompiler","commit_stats":{"total_commits":1290,"total_committers":26,"mean_commits":49.61538461538461,"dds":0.3434108527131783,"last_synced_commit":"23d6b132571b62565f79e4082409f3cf5c169938"},"previous_names":[],"tags_count":30,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dadhi%2FFastExpressionCompiler","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dadhi%2FFastExpressionCompiler/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dadhi%2FFastExpressionCompiler/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/dadhi%2FFastExpressionCompiler/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/dadhi","download_url":"https://codeload.github.com/dadhi/FastExpressionCompiler/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":253969260,"owners_count":21992263,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["benchmark","closure","code-generation","compiler","delegate","delegates","dryioc","expression-tree","il-optimizations","performance"],"created_at":"2024-09-26T02:47:56.545Z","updated_at":"2025-05-13T15:11:30.787Z","avatar_url":"https://github.com/dadhi.png","language":"C#","readme":"# FastExpressionCompiler\n\n\u003cimg src=\"./logo.png\" alt=\"logo\"/\u003e\n\n[DryIoc]: https://github.com/dadhi/DryIoc\n[ExpressionToCodeLib]: https://github.com/EamonNerbonne/ExpressionToCode\n[ExpressionTree]: https://msdn.microsoft.com/en-us/library/mt654263.aspx\n[Marten]: https://github.com/JasperFx/marten\n[Rebus]: https://github.com/rebus-org/Rebus\n[StructureMap]: https://github.com/structuremap/structuremap\n[Lamar]: https://github.com/JasperFx/lamar\n[NServiceBus]: https://github.com/Particular/NServiceBus/pull/5071\n\n[LINQ2DB]: https://github.com/linq2db/linq2db/pull/1277\n[Moq]: https://github.com/moq/moq4/issues/504#issuecomment-406714210\n[Apex.Serialization]: https://github.com/dbolin/Apex.Serialization\n[MapsterMapper]: https://github.com/MapsterMapper/Mapster \n\n[![latest release notes](https://img.shields.io/badge/latest%20release%20notes-v5.1.1-blue)](https://github.com/dadhi/FastExpressionCompiler/releases/tag/v5.1.1)\n[![Windows build](https://ci.appveyor.com/api/projects/status/4iyhed69l3k0k37o/branch/master?svg=true)](https://ci.appveyor.com/project/MaksimVolkau/fastexpressioncompiler/branch/master)[![license](https://img.shields.io/github/license/dadhi/FastExpressionCompiler.svg)](http://opensource.org/licenses/MIT)  \n\nTargets .NET 6+, .NET 4.7.2+, .NET Standard 2.0+\n\nNuGet packages:\n\n- FastExpressionCompiler [![NuGet Version](https://img.shields.io/nuget/v/FastExpressionCompiler)](https://www.nuget.org/packages/FastExpressionCompiler)![NuGet Downloads](https://img.shields.io/nuget/dt/FastExpressionCompiler)\n  * sources package: FastExpressionCompiler.src [![NuGet Version](https://img.shields.io/nuget/v/FastExpressionCompiler.src)](https://www.nuget.org/packages/FastExpressionCompiler.src)![NuGet Downloads](https://img.shields.io/nuget/dt/FastExpressionCompiler.src)\n  * sources with the public code made internal: FastExpressionCompiler.Internal.src [![NuGet Version](https://img.shields.io/nuget/v/FastExpressionCompiler.Internal.src)](https://www.nuget.org/packages/FastExpressionCompiler.Internal.src)![NuGet Downloads](https://img.shields.io/nuget/dt/FastExpressionCompiler.Internal.src)\n- FastExpressionCompiler.LightExpression [![NuGet Version](https://img.shields.io/nuget/v/FastExpressionCompiler.LightExpression)](https://www.nuget.org/packages/FastExpressionCompiler.LightExpression)![NuGet Downloads](https://img.shields.io/nuget/dt/FastExpressionCompiler.LightExpression)  \n  * sources package: FastExpressionCompiler.LightExpression.src [![NuGet Version](https://img.shields.io/nuget/v/FastExpressionCompiler.LightExpression.src)](https://www.nuget.org/packages/FastExpressionCompiler.LightExpression.src)![NuGet Downloads](https://img.shields.io/nuget/dt/FastExpressionCompiler.LightExpression.src)  \n  * sources with the public code made internal: FastExpressionCompiler.LightExpression.Internal.src [![NuGet Version](https://img.shields.io/nuget/v/FastExpressionCompiler.LightExpression.Internal.src)](https://www.nuget.org/packages/FastExpressionCompiler.LightExpression.Internal.src)![NuGet Downloads](https://img.shields.io/nuget/dt/FastExpressionCompiler.LightExpression.Internal.src)\n\nThe project was originally a part of the [DryIoc], so check it out ;-)\n\n## The problem\n\n[ExpressionTree] compilation is used by the wide variety of tools, e.g. IoC/DI containers, Serializers, ORMs and OOMs.\nBut `Expression.Compile()` is just slow. \nMoreover the compiled delegate may be slower than the manually created delegate because of the [reasons](https://blogs.msdn.microsoft.com/seteplia/2017/02/01/dissecting-the-new-constraint-in-c-a-perfect-example-of-a-leaky-abstraction/):\n\n_TL;DR;_\n\u003e Expression.Compile creates a DynamicMethod and associates it with an anonymous assembly to run it in a sand-boxed environment. This makes it safe for a dynamic method to be emitted and executed by partially trusted code but adds some run-time overhead.\n\nSee also [a deep dive to Delegate internals](https://mattwarren.org/2017/01/25/How-do-.NET-delegates-work/#different-types-of-delegates).\n\n\n## The solution\n\nThe FastExpressionCompiler `.CompileFast()` extension method is __10-40x times faster__ than `.Compile()`.  \nThe compiled delegate may be _in some cases_ a lot faster than the one produced by `.Compile()`.\n\n__Note:__ The actual performance may vary depending on the multiple factors: \nplatform, how complex is expression, does it have a closure, does it contain nested lambdas, etc.\n\nIn addition, the memory consumption taken by the compilation will be much smaller (check the `Allocated` column in the [benchmarks](#benchmarks) below).\n\n## Benchmarks\n\n**Updated to .NET 9.0**\n\n```ini\nBenchmarkDotNet v0.14.0, Windows 11 (10.0.22631.4391/23H2/2023Update/SunValley3)\nIntel Core i9-8950HK CPU 2.90GHz (Coffee Lake), 1 CPU, 12 logical and 6 physical cores\n.NET SDK 9.0.100\n  [Host]     : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX2\n  DefaultJob : .NET 9.0.0 (9.0.24.52809), X64 RyuJIT AVX2\n```\n\n### Hoisted expression with the constructor and two arguments in closure\n\n```cs\nvar a = new A();\nvar b = new B();\nExpression\u003cFunc\u003cX\u003e\u003e e = () =\u003e new X(a, b);\n```\n\nCompiling expression:\n\n| Method      |       Mean |     Error |    StdDev | Ratio | RatioSD |   Gen0 |   Gen1 | Allocated | Alloc Ratio |\n| ----------- | ---------: | --------: | --------: | ----: | ------: | -----: | -----: | --------: | ----------: |\n| Compile     | 151.570 us | 3.0196 us | 6.7538 us | 44.27 |    2.13 | 0.7324 |      - |   4.49 KB |        2.92 |\n| CompileFast |   3.425 us | 0.0676 us | 0.0664 us |  1.00 |    0.03 | 0.2441 | 0.2365 |   1.54 KB |        1.00 |\n\nInvoking the compiled delegate (comparing to the direct constructor call):\n\n| Method                |     Mean |     Error |    StdDev |   Median | Ratio | RatioSD |   Gen0 | Allocated | Alloc Ratio |\n| --------------------- | -------: | --------: | --------: | -------: | ----: | ------: | -----: | --------: | ----------: |\n| DirectConstructorCall | 6.920 ns | 0.2007 ns | 0.3462 ns | 7.051 ns |  0.86 |    0.06 | 0.0051 |      32 B |        1.00 |\n| CompiledLambda        | 8.095 ns | 0.2195 ns | 0.5216 ns | 7.845 ns |  1.01 |    0.08 | 0.0051 |      32 B |        1.00 |\n| FastCompiledLambda    | 8.066 ns | 0.2206 ns | 0.3234 ns | 8.156 ns |  1.00 |    0.06 | 0.0051 |      32 B |        1.00 |\n\n\n### Hoisted expression with the static method and two nested lambdas and two arguments in closure\n\n```cs\nvar a = new A();\nvar b = new B();\nExpression\u003cFunc\u003cX\u003e\u003e getXExpr = () =\u003e CreateX((aa, bb) =\u003e new X(aa, bb), new Lazy\u003cA\u003e(() =\u003e a), b);\n```\n\nCompiling expression:\n\n| Method      |      Mean |    Error |    StdDev |    Median | Ratio | RatioSD |   Gen0 |   Gen1 | Allocated | Alloc Ratio |\n| ----------- | --------: | -------: | --------: | --------: | ----: | ------: | -----: | -----: | --------: | ----------: |\n| Compile     | 421.09 us | 8.382 us | 18.221 us | 413.02 us | 36.29 |    2.09 | 1.9531 | 0.9766 |  12.04 KB |        2.61 |\n| CompileFast |  11.62 us | 0.230 us |  0.464 us |  11.42 us |  1.00 |    0.06 | 0.7324 | 0.7019 |   4.62 KB |        1.00 |\n\n\nInvoking compiled delegate comparing to direct method call:\n\n| Method              |        Mean |     Error |    StdDev |      Median | Ratio | RatioSD |   Gen0 | Allocated | Alloc Ratio |\n| ------------------- | ----------: | --------: | --------: | ----------: | ----: | ------: | -----: | --------: | ----------: |\n| DirectMethodCall    |    43.45 ns |  0.922 ns |  1.905 ns |    44.13 ns |  1.09 |    0.08 | 0.0268 |     168 B |        1.62 |\n| Invoke_Compiled     | 1,181.25 ns | 23.664 ns | 56.240 ns | 1,161.87 ns | 29.66 |    2.24 | 0.0420 |     264 B |        2.54 |\n| Invoke_CompiledFast |    39.96 ns |  0.856 ns |  2.442 ns |    38.96 ns |  1.00 |    0.08 | 0.0166 |     104 B |        1.00 |\n\n\n### Manually composed expression with parameters and closure\n\n```cs\nvar a = new A();\nvar bParamExpr = Expression.Parameter(typeof(B), \"b\");\nvar expr = Expression.Lambda(\n    Expression.New(_ctorX,\n        Expression.Constant(a, typeof(A)), bParamExpr),\n    bParamExpr);\n```\n\nCompiling expression:\n\n| Method                       |      Mean |     Error |    StdDev |    Median | Ratio | RatioSD |   Gen0 |   Gen1 | Allocated | Alloc Ratio |\n| ---------------------------- | --------: | --------: | --------: | --------: | ----: | ------: | -----: | -----: | --------: | ----------: |\n| Compile_SystemExpression     | 89.076 us | 2.6699 us | 7.6605 us | 85.180 us | 28.12 |    3.05 | 0.7324 | 0.4883 |   4.74 KB |        3.41 |\n| CompileFast_SystemExpression |  3.138 us | 0.0550 us | 0.0565 us |  3.118 us |  0.99 |    0.03 | 0.2213 | 0.2136 |   1.39 KB |        1.00 |\n| CompileFast_LightExpression  |  3.180 us | 0.0602 us | 0.0591 us |  3.163 us |  1.00 |    0.00 | 0.2213 | 0.2136 |   1.39 KB |        1.00 |\n\n\nInvoking the compiled delegate compared to the normal delegate and the direct call:\n\n| Method                        |     Mean |     Error |    StdDev |   Median | Ratio | RatioSD |   Gen0 | Allocated | Alloc Ratio |\n| ----------------------------- | -------: | --------: | --------: | -------: | ----: | ------: | -----: | --------: | ----------: |\n| DirectCall                    | 8.388 ns | 0.2655 ns | 0.7575 ns | 8.092 ns |  1.00 |    0.07 | 0.0051 |      32 B |        1.00 |\n| Compiled_SystemExpression     | 9.474 ns | 0.1870 ns | 0.4105 ns | 9.381 ns |  1.10 |    0.05 | 0.0051 |      32 B |        1.00 |\n| CompiledFast_SystemExpression | 8.575 ns | 0.1624 ns | 0.1440 ns | 8.517 ns |  1.00 |    0.02 | 0.0051 |      32 B |        1.00 |\n| CompiledFast_LightExpression  | 8.584 ns | 0.0776 ns | 0.0862 ns | 8.594 ns |  1.00 |    0.00 | 0.0051 |      32 B |        1.00 |\n\n\n### FastExpressionCompiler.LightExpression.Expression vs System.Linq.Expressions.Expression\n\n`FastExpressionCompiler.LightExpression.Expression` is the lightweight version of `System.Linq.Expressions.Expression`. \nIt is designed to be a __drop-in replacement__ for the System Expression - just install the __FastExpressionCompiler.LightExpression__ package instead of __FastExpressionCompiler__ and replace the usings\n\n```cs\nusing System.Linq.Expressions;\nusing static System.Linq.Expressions.Expression;\n```\n\nwith\n\n```cs\nusing static FastExpressionCompiler.LightExpression.Expression;\nnamespace FastExpressionCompiler.LightExpression.UnitTests\n```\n\nYou may look at it as a bare-bone wrapper for the computation operation node which helps you to compose the computation tree (without messing with the IL emit directly).\nIt __won't validate operations compatibility__ for the tree the way `System.Linq.Expression` does it, and partially why it is so slow.\nHopefully you are checking the expression arguments yourself and not waiting for the `Expression` exceptions to blow-up.\n\n[Sample expression](https://github.com/dadhi/FastExpressionCompiler/blob/6da130c62f6adaa293f34a1a0c19ea4522f9c989/test/FastExpressionCompiler.LightExpression.UnitTests/LightExpressionTests.cs#L167)\n\nCreating the expression:\n\n| Method                                 |       Mean |    Error |   StdDev |     Median | Ratio | RatioSD |   Gen0 | Allocated | Alloc Ratio |\n| -------------------------------------- | ---------: | -------: | -------: | ---------: | ----: | ------: | -----: | --------: | ----------: |\n| Create_SystemExpression                | 1,110.9 ns | 22.19 ns | 62.23 ns | 1,086.1 ns |  7.25 |    0.56 | 0.2060 |    1304 B |        2.63 |\n| Create_LightExpression                 |   153.7 ns |  3.14 ns |  8.61 ns |   150.5 ns |  1.00 |    0.08 | 0.0789 |     496 B |        1.00 |\n| Create_LightExpression_with_intrinsics |   161.0 ns |  2.80 ns |  2.19 ns |   161.0 ns |  1.05 |    0.06 | 0.0777 |     488 B |        0.98 |\n\nCreating and compiling:\n\n| Method                                               |       Mean |     Error |     StdDev | Ratio | RatioSD |   Gen0 |   Gen1 | Allocated | Alloc Ratio |\n| ---------------------------------------------------- | ---------: | --------: | ---------: | ----: | ------: | -----: | -----: | --------: | ----------: |\n| Create_SystemExpression_and_Compile                  | 212.157 us | 4.2180 us | 11.4036 us | 44.77 |    3.31 | 0.9766 | 0.4883 |   7.15 KB |        2.95 |\n| Create_SystemExpression_and_CompileFast              |   6.656 us | 0.1322 us |  0.3065 us |  1.40 |    0.10 | 0.5188 | 0.4883 |   3.27 KB |        1.35 |\n| Create_LightExpression_and_CompileFast               |   4.751 us | 0.0947 us |  0.2411 us |  1.00 |    0.07 | 0.3815 | 0.3662 |   2.42 KB |        1.00 |\n| CreateLightExpression_and_CompileFast_with_intrinsic |   4.604 us | 0.0918 us |  0.1915 us |  0.97 |    0.06 | 0.3815 | 0.3662 |   2.35 KB |        0.97 |\n\n\n## Difference between FastExpressionCompiler and FastExpressionCompiler.LightExpression\n\nFastExpressionCompiler\n\n- Provides the `CompileFast` extension methods for the `System.Linq.Expressions.LambdaExpression`.\n\nFastExpressionCompiler.LightExpression\n\n- Provides the `CompileFast` extension methods for `FastExpressionCompiler.LightExpression.LambdaExpression`.\n- Provides the drop-in expression replacement with the less consumed memory and the faster construction at the cost of the less validation.\n- Includes its own `ExpressionVisitor`.\n- Supports `ToExpression` method to convert back **to the** `System.Linq.Expressions.Expression`.\n- Supports `ToLightExpression` conversion method to convert **from the** `System.Linq.Expressions.Expression` to `FastExpressionCompiler.LightExpression.Expression`.\n\nBoth FastExpressionCompiler and FastExpressionCompiler.LightExpression\n\n- Support `ToCSharpString()` method to output the compilable C# code represented by the expression.\n- Support `ToExpressionString()` method to output the expression construction C# code, so given the expression object you'll get e.g. `Expression.Lambda(Expression.New(...))`.\n\n\n## Who's using it\n\n[Marten], [Rebus], [StructureMap], [Lamar], [ExpressionToCodeLib], [NServiceBus], [LINQ2DB], [MapsterMapper]\n\nConsidering: [Moq], [Apex.Serialization]\n\n\n## How to use\n\nInstall from the NuGet and add the `using FastExpressionCompiler;` and replace the call to the `.Compile()` with the `.CompileFast()` extension method.\n\n__Note:__ `CompileFast` has an optional parameter `bool ifFastFailedReturnNull = false` to disable fallback to `Compile`.\n\n### Examples\n\nHoisted lambda expression (created by the C# Compiler):\n\n```cs\nvar a = new A(); var b = new B();\nExpression\u003cFunc\u003cX\u003e\u003e expr = () =\u003e new X(a, b);\n\nvar getX = expr.CompileFast();\nvar x = getX();\n```\n\nManually composed lambda expression:\n\n```cs\nvar a = new A();\nvar bParamExpr = Expression.Parameter(typeof(B), \"b\");\nvar expr = Expression.Lambda(\n    Expression.New(_ctorX,\n        Expression.Constant(a, typeof(A)), bParamExpr),\n    bParamExpr);\n\nvar f = expr.CompileFast();\nvar x = f(new B());\n```\n\n__Note:__ You may simplify Expression usage and enable faster refactoring with the C# `using static` statement:\n\n```cs\nusing static System.Linq.Expressions.Expression;\n// or\n// using static FastExpressionCompiler.LightExpression.Expression;\n\nvar a = new A();\nvar bParamExpr = Parameter(typeof(B), \"b\");\nvar expr = Lambda(\n    New(_ctorX, Constant(a, typeof(A)), bParamExpr),\n    bParamExpr);\n\nvar f = expr.CompileFast();\nvar x = f(new B());\n```\n\n\n## How it works\n\nThe idea is to provide the fast compilation for the supported expression types\nand fallback to the system `Expression.Compile()` for the not supported types:\n\n### What's not supported yet\n\n**FEC does not support yet:** \n\n- `Quote`\n- `Dynamic`\n- `RuntimeVariables`\n- `DebugInfo`\n- `MemberInit` with the `MemberMemberBinding` and the `ListMemberBinding` binding types\n- `NewArrayInit` multi-dimensional array initializer is not supported yet\n\nTo find what nodes are not supported in your expression you may use the technic described below in the [Diagnostics](#diagnostics) section. \n\nThe compilation is done by traversing the expression nodes and emitting the IL. \nThe code is tuned for the performance and the minimal memory consumption. \n\nThe expression is traversed twice:\n\n- 1st round is to collect the constants and nested lambdas into the closure objects.\n- 2nd round is to emit the IL code and create the delegate using the `DynamicMethod`.\n\nIf visitor finds the not supported expression node or the error condition, \nthe compilation is aborted, and `null` is returned enabling the fallback to System `.Compile()`.\n\n\n## Diagnostics and Code Generation\n\nFEC V3 has added powerful diagnostics and code generation tools.\n\n### Diagnostics\n\nYou may pass the optional `CompilerFlags.EnableDelegateDebugInfo`  into the `CompileFast` methods.\n\n`EnableDelegateDebugInfo` adds the diagnostic info into the compiled delegate including its source Expression and C# code. \nCan be used as following:\n\n```cs\nvar f = e.CompileFast(true, CompilerFlags.EnableDelegateDebugInfo);\nvar di = f.Target as IDelegateDebugInfo;\nAsserts.IsNotNull(di.Expression);\nAsserts.IsNotNull(di.ExpressionString);\nAsserts.IsNotNull(di.CSharpString);\n```\n\n### ThrowOnNotSupportedExpression and NotSupported_ flags\n\nFEC V3.1 has added the compiler flag `CompilerFlags.ThrowOnNotSupportedExpression`.\nWhen passed to `CompileFast(flags: CompilerFlags.ThrowOnNotSupportedExpression)` and the expression contains not (yet) supported Expression node the compilation will throw the exception instead of returning `null`.\n\nTo get the whole list of the not yet supported cases you may check in `Result.NotSupported_` enum values.\n\n\n### Code Generation\n\nThe Code Generation capabilities are available via the `ToCSharpString` and `ToExpressionString` extension methods.\n\n**Note:** When converting the source expression to either C# code or to the Expression construction code you may find \nthe `// NOT_SUPPORTED_EXPRESSION` comments marking the not supported yet expressions by FEC. So you may test the presence or absence of this comment.\n\n\n## Additional optimizations\n\n1. Using `FastExpressionCompiler.LightExpression.Expression` instead of `System.Linq.Expressions.Expression` for the faster expression creation.  \n2. Using `.TryCompileWithPreCreatedClosure` and `.TryCompileWithoutClosure` methods when you know the expression at hand and may skip the first traversing round, e.g. for the \"static\" expression which does not contain the bound constants. __Note:__ You cannot skip the 1st round if the expression contains the `Block`, `Try`, or `Goto` expressions.\n\n---\n\u003ca target=\"_blank\" href=\"https://icons8.com/icons/set/bitten-ice-pop\"\u003eBitten Ice Pop icon\u003c/a\u003e icon by \u003ca target=\"_blank\" href=\"https://icons8.com\"\u003eIcons8\u003c/a\u003e\n","funding_links":["https://github.com/sponsors/dadhi"],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdadhi%2Ffastexpressioncompiler","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fdadhi%2Ffastexpressioncompiler","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdadhi%2Ffastexpressioncompiler/lists"}