diff --git a/ExpressionEngine/ExpressionEngineDIExtensions.cs b/ExpressionEngine/ExpressionEngineDIExtensions.cs
new file mode 100644
index 0000000..39b9076
--- /dev/null
+++ b/ExpressionEngine/ExpressionEngineDIExtensions.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using ExpressionEngine.Functions.Base;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace ExpressionEngine
+{
+    /// <summary>
+    /// Extension methods for service collection
+    /// </summary>
+    public static class ExpressionEngineDiExtensions
+    {
+        /// <summary>
+        /// Find function implementations registered with <see cref="FunctionRegistrationAttribute"/>.
+        /// 
+        /// The function only scans the given type's assembly
+        /// </summary>
+        /// <param name="serviceCollection"></param>
+        /// <typeparam name="T">Assembly to scan</typeparam>
+        /// <exception cref="ArgumentOutOfRangeException"></exception>
+        /// <returns></returns>
+        public static IServiceCollection WithFunctionDiscovery<T>(this IServiceCollection serviceCollection)
+        {
+            var addFunctionMethodInfo = typeof(ExpressionEngineDiExtensions).GetMethod(nameof(AddFunction));
+
+            if (addFunctionMethodInfo == null)
+                throw new Exception();
+
+            var functions =
+                typeof(T)
+                    .Assembly
+                    .GetTypes()
+                    .Where(t => t.GetCustomAttributes<FunctionRegistrationAttribute>().Any());
+
+            foreach (var function in functions)
+            {
+                var generic = addFunctionMethodInfo.MakeGenericMethod(function);
+                generic.Invoke(null, new object[] {serviceCollection});
+            }
+
+            return serviceCollection;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="serviceCollection"></param>
+        /// <typeparam name="T"></typeparam>
+        private static void AddFunction<T>(IServiceCollection serviceCollection) where T : class, IFunction
+        {
+            serviceCollection.AddFunction<T>();
+        }
+    }
+}
\ No newline at end of file
diff --git a/ExpressionEngine/FlowRunnerDependencyExtension.cs b/ExpressionEngine/FlowRunnerDependencyExtension.cs
index 66050da..d74a77e 100644
--- a/ExpressionEngine/FlowRunnerDependencyExtension.cs
+++ b/ExpressionEngine/FlowRunnerDependencyExtension.cs
@@ -1,11 +1,6 @@
 using System;
 using ExpressionEngine.Functions.Base;
 using ExpressionEngine.Functions.CustomException;
-using ExpressionEngine.Functions.Implementations.CollectionFunctions;
-using ExpressionEngine.Functions.Implementations.ConversionFunctions;
-using ExpressionEngine.Functions.Implementations.LogicalComparisonFunctions;
-using ExpressionEngine.Functions.Implementations.StringFunctions;
-using ExpressionEngine.Functions.Math;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace ExpressionEngine
@@ -15,6 +10,7 @@ namespace ExpressionEngine
     /// </summary>
     public static class FlowRunnerDependencyExtension
     {
+
         /// <summary>
         /// Add necessary dependencies inorder to use expression engine. 
         /// </summary>
@@ -24,35 +20,30 @@ public static void AddExpressionEngine(this IServiceCollection services)
             services.AddScoped<IExpressionEngine, ExpressionEngine>();
             services.AddScoped<ExpressionGrammar>();
 
-            AddStringFunctions(services);
-            AddCollectionFunction(services);
-            AddConversionFunction(services);
-            AddLogicalComparisonFunctions(services);
-            AddMathFunctions(services);
-
-            services.RegisterTransientFunctionAlias<LengthFunction>("length");
-            services.RegisterTransientFunctionAlias<GreaterFunction>("greater");
+            services.WithFunctionDiscovery<Functions.Functions>();
         }
-        
+
         /// <summary>
         /// Register function to be used in expression, function implementation must implement <see cref="IFunction"/>.
         /// </summary>
         /// <param name="services">Services which to add function metadata</param>
         /// <param name="functionName">name of function used to invoke it</param>
         /// <typeparam name="T">Function implementation</typeparam>
+        [Obsolete("Use '.AddFunction().AsTransient().WithAlias(<string>)' instead")]
         public static void RegisterTransientFunctionAlias<T>(this IServiceCollection services, string functionName)
             where T : class, IFunction
         {
             services.AddTransient<T>();
             services.AddSingleton(new FunctionMetadata(typeof(T), functionName));
         }
-        
+
         /// <summary>
         /// Register function to be used in expression, function implementation must implement <see cref="IFunction"/>.
         /// </summary>
         /// <param name="services">Services which to add function metadata</param>
         /// <param name="functionName">name of function used to invoke it</param>
         /// <typeparam name="T">Function implementation</typeparam>
+        [Obsolete("Use '.AddFunction().AsScoped().WithAlias(<string>)' instead")]
         public static void RegisterScopedFunctionAlias<T>(this IServiceCollection services, string functionName)
             where T : class, IFunction
         {
@@ -67,6 +58,7 @@ public static void RegisterScopedFunctionAlias<T>(this IServiceCollection servic
         /// <param name="functionName">name of function used to invoke it</param>
         /// <param name="implementationFactory"></param>
         /// <typeparam name="T">Function implementation</typeparam>
+        [Obsolete("Use '.AddFunction<T>(<factory>).AsScoped().WithAlias(<string>)' instead")]
         public static void RegisterScopedFunctionAlias<T>(this IServiceCollection services, string functionName,
             Func<IServiceProvider, T> implementationFactory)
             where T : class, IFunction
@@ -81,87 +73,16 @@ public static void RegisterScopedFunctionAlias<T>(this IServiceCollection servic
         /// <param name="services"></param>
         /// <param name="fromFunctionName">The name of the function, without function parenthesis</param>
         /// <param name="toExpression">The full expression which is inserted</param>
-        public static void AddFunctionDefinition(this IServiceCollection services, string fromFunctionName, string toExpression)
+        public static void AddFunctionDefinition(this IServiceCollection services, string fromFunctionName,
+            string toExpression)
         {
             if (fromFunctionName.EndsWith("()"))
             {
                 throw new ArgumentError($"{nameof(fromFunctionName)} cannot end in ()");
             }
 
-            services.AddSingleton<IFunctionDefinition>(new FunctionDefinition{From = fromFunctionName + "()", To = toExpression});
-        }
-
-        private static void AddStringFunctions(IServiceCollection services)
-        {
-            services.RegisterTransientFunctionAlias<ConcatFunction>("concat");
-            services.RegisterTransientFunctionAlias<EndsWithFunction>("endsWith");
-            services.RegisterTransientFunctionAlias<FormatNumberFunction>("formatNumber");
-            services.RegisterTransientFunctionAlias<GuidFunction>("guid");
-            services.RegisterTransientFunctionAlias<IndexOfFunction>("indexOf");
-            services.RegisterTransientFunctionAlias<LastIndexOfFunction>("lastIndexOf");
-            services.RegisterTransientFunctionAlias<LengthFunction>("length");
-            services.RegisterTransientFunctionAlias<ReplaceFunction>("replace");
-            services.RegisterTransientFunctionAlias<SplitFunction>("split");
-            services.RegisterTransientFunctionAlias<StartsWithFunction>("startsWith");
-            services.RegisterTransientFunctionAlias<SubstringFunction>("substring");
-            services.RegisterTransientFunctionAlias<ToLowerFunction>("toLower");
-            services.RegisterTransientFunctionAlias<ToUpperFunction>("toUpper");
-            services.RegisterTransientFunctionAlias<TrimFunction>("trim");
-        }
-
-        private static void AddCollectionFunction(IServiceCollection services)
-        {
-            services.RegisterTransientFunctionAlias<ContainsFunction>("contains");
-            services.RegisterTransientFunctionAlias<EmptyFunction>("empty");
-            services.RegisterTransientFunctionAlias<FirstFunction>("first");
-            services.RegisterTransientFunctionAlias<InterSectionFunction>("intersection");
-            services.RegisterTransientFunctionAlias<JoinFunction>("join");
-            services.RegisterTransientFunctionAlias<LastFunction>("last");
-            services.RegisterTransientFunctionAlias<LengthFunction>("length");
-            services.RegisterTransientFunctionAlias<SkipFunction>("skip");
-            services.RegisterTransientFunctionAlias<TakeFunction>("take");
-            services.RegisterTransientFunctionAlias<UnionFunction>("union");
-        }
-
-        private static void AddConversionFunction(IServiceCollection services)
-        {
-            services.RegisterTransientFunctionAlias<ArrayFunction>("array");
-            services.RegisterTransientFunctionAlias<Base64Function>("base64");
-            services.RegisterTransientFunctionAlias<Base64ToBinaryFunction>("base64ToBinary");
-            services.RegisterTransientFunctionAlias<Base64ToStringFunction>("base64ToString");
-            services.RegisterTransientFunctionAlias<BinaryFunction>("binary");
-            services.RegisterTransientFunctionAlias<BoolFunction>("bool");
-            services.RegisterTransientFunctionAlias<CreateArrayFunction>("createArray");
-            services.RegisterTransientFunctionAlias<DataUriFunction>("dataUri");
-            services.RegisterTransientFunctionAlias<DataUriToBinaryFunction>("dataUriToBinary");
-            services.RegisterTransientFunctionAlias<FloatFunction>("float");
-            services.RegisterTransientFunctionAlias<IntFunction>("int");
-        }
-
-        private static void AddLogicalComparisonFunctions(IServiceCollection services)
-        {
-            services.RegisterTransientFunctionAlias<AndFunction>("and");
-            services.RegisterTransientFunctionAlias<EqualFunction>("equal");
-            services.RegisterTransientFunctionAlias<GreaterFunction>("greater");
-            services.RegisterTransientFunctionAlias<GreaterOrEqualsFunction>("greaterOrEquals");
-            services.RegisterTransientFunctionAlias<IfFunction>("if");
-            services.RegisterTransientFunctionAlias<LessFunction>("less");
-            services.RegisterTransientFunctionAlias<LessOrEqualsFunction>("lessOrEquals");
-            services.RegisterTransientFunctionAlias<NotFunction>("not");
-            services.RegisterTransientFunctionAlias<OrFunction>("or");
-        }
-
-        private static void AddMathFunctions(IServiceCollection services)
-        {
-            services.RegisterTransientFunctionAlias<AddFunction>("add");
-            services.RegisterTransientFunctionAlias<DivFunction>("div");
-            services.RegisterTransientFunctionAlias<MaxFunction>("max");
-            services.RegisterTransientFunctionAlias<MinFunction>("min");
-            services.RegisterTransientFunctionAlias<ModFunction>("mod");
-            services.RegisterTransientFunctionAlias<MulFunction>("mul");
-            services.RegisterTransientFunctionAlias<RandFunction>("rand");
-            services.RegisterTransientFunctionAlias<RangeFunction>("range");
-            services.RegisterTransientFunctionAlias<SubFunction>("sub");
+            services.AddSingleton<IFunctionDefinition>(new FunctionDefinition
+                {From = fromFunctionName + "()", To = toExpression});
         }
     }
 }
\ No newline at end of file
diff --git a/ExpressionEngine/FunctionBuilder.cs b/ExpressionEngine/FunctionBuilder.cs
new file mode 100644
index 0000000..e019ee9
--- /dev/null
+++ b/ExpressionEngine/FunctionBuilder.cs
@@ -0,0 +1,141 @@
+using System;
+using System.Reflection;
+using ExpressionEngine.Functions.Base;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace ExpressionEngine
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public static class FunctionBuilderExt
+    {
+        /// <summary>
+        /// Initiate Function builder for registering a Function, preloaded with <see cref="FunctionRegistrationAttribute"/>
+        /// </summary>
+        /// <param name="serviceCollection">ServiceCollection to which the function is registered</param>
+        /// <typeparam name="TFunction">Type of the Function</typeparam>
+        /// <returns></returns>
+        public static FunctionBuilder<TFunction> BuildFunction<TFunction>(this IServiceCollection serviceCollection)
+            where TFunction : class, IFunction
+        {
+            var t = new FunctionBuilder<TFunction>(serviceCollection);
+
+            var functionRegistrationAttributes = typeof(TFunction).GetCustomAttributes<FunctionRegistrationAttribute>();
+
+            foreach (var functionRegistrationAttribute in functionRegistrationAttributes)
+            {
+                t.SetScope(functionRegistrationAttribute.Scope);
+                t.WithAlias(functionRegistrationAttribute.FunctionName);
+            }
+
+            return t;
+        }
+
+        /// <summary>
+        /// Add function using <see cref="FunctionRegistrationAttribute"/>
+        /// </summary>
+        /// <param name="serviceCollection">ServiceCollection to which the function is registered</param>
+        /// <typeparam name="TFunction">Type of the Function</typeparam>
+        /// <returns></returns>
+        public static IServiceCollection AddFunction<TFunction>(this IServiceCollection serviceCollection)
+            where TFunction : class, IFunction
+        {
+            return serviceCollection.BuildFunction<TFunction>().Add();
+        }
+    }
+
+    /// <summary>
+    /// FunctionBuilder is responsible for adding a Function properly
+    /// </summary>
+    /// <typeparam name="T">Type of the Function</typeparam>
+    public class FunctionBuilder<T> where T : class, IFunction
+    {
+        private readonly IServiceCollection _serviceCollection;
+        private Scope _scope = Scope.Transient;
+
+        /// <summary>
+        /// Set scope without using As{Scope}
+        /// </summary>
+        /// <param name="scope"></param>
+        internal void SetScope(Scope scope)
+        {
+            _scope = scope;
+        }
+
+        /// <summary>
+        /// Create function builder 
+        /// </summary>
+        /// <param name="serviceCollection">ServiceCollection to which the function is registered</param>
+        public FunctionBuilder(IServiceCollection serviceCollection)
+        {
+            _serviceCollection = serviceCollection;
+        }
+
+        /// <summary>
+        /// Add Function as transient
+        /// </summary>
+        /// <returns>builder</returns>
+        public FunctionBuilder<T> AsTransient()
+        {
+            _scope = Scope.Transient;
+            return this;
+        }
+
+        /// <summary>
+        /// Add Function as scoped
+        /// </summary>
+        /// <returns>builder</returns>
+        public FunctionBuilder<T> AsScoped()
+        {
+            _scope = Scope.Scoped;
+            return this;
+        }
+
+        /// <summary>
+        /// Add Function as singleton
+        /// </summary>
+        /// <returns>builder</returns>
+        public FunctionBuilder<T> AsSingleton()
+        {
+            _scope = Scope.Singleton;
+            return this;
+        }
+
+        /// <summary>
+        /// Associate alias with Function, an alias can be used to invoke a function.
+        /// </summary>
+        /// <param name="alias">function alias</param>
+        /// <returns>builder</returns>
+        public FunctionBuilder<T> WithAlias(string alias)
+        {
+            _serviceCollection.AddSingleton(new FunctionMetadata(typeof(T), alias));
+            return this;
+        }
+
+        /// <summary>
+        /// Add build Function to ServiceCollection
+        /// </summary>
+        /// <returns></returns>
+        /// <exception cref="ArgumentOutOfRangeException"></exception>
+        public IServiceCollection Add()
+        {
+            switch (_scope)
+            {
+                case Scope.Scoped:
+                    _serviceCollection.AddScoped<T>();
+                    break;
+                case Scope.Transient:
+                    _serviceCollection.AddTransient<T>();
+                    break;
+                case Scope.Singleton:
+                    _serviceCollection.AddSingleton<T>();
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+
+            return _serviceCollection;
+        }
+    }
+}
\ No newline at end of file
diff --git a/ExpressionEngine/FunctionRegistrationAttribute.cs b/ExpressionEngine/FunctionRegistrationAttribute.cs
new file mode 100644
index 0000000..c9175d5
--- /dev/null
+++ b/ExpressionEngine/FunctionRegistrationAttribute.cs
@@ -0,0 +1,29 @@
+using System;
+
+namespace ExpressionEngine
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
+    public class FunctionRegistrationAttribute : Attribute
+    {
+        /// <summary>
+        /// Function Name
+        /// </summary>
+        public string FunctionName { get; }
+        public Scope Scope { get; }
+
+        /// <summary>
+        /// Enable function to be discovered by <code>.WithFunctionDiscovery$lt{T}$gt</code> <see cref="ExpressionEngineDiExtensions"/>.
+        /// Or to be added easily with .AddFunction;
+        /// </summary>
+        /// <param name="functionName">Name of function</param>
+        /// <param name="scope">DI Scope - defaults to Transient</param>
+        public FunctionRegistrationAttribute(string functionName, Scope scope = Scope.Transient)
+        {
+            FunctionName = functionName;
+            Scope = scope;
+        }
+    }
+}
\ No newline at end of file
diff --git a/ExpressionEngine/Functions/Functions.cs b/ExpressionEngine/Functions/Functions.cs
new file mode 100644
index 0000000..3bdbc29
--- /dev/null
+++ b/ExpressionEngine/Functions/Functions.cs
@@ -0,0 +1,10 @@
+namespace ExpressionEngine.Functions
+{
+    /// <summary>
+    /// Is used to discover functions within this namespace
+    /// </summary>
+    public abstract class Functions
+    {
+        
+    }
+}
\ No newline at end of file
diff --git a/ExpressionEngine/Functions/Implementations/CollectionFunctions/ContainsFunction.cs b/ExpressionEngine/Functions/Implementations/CollectionFunctions/ContainsFunction.cs
index c7254aa..c36d065 100644
--- a/ExpressionEngine/Functions/Implementations/CollectionFunctions/ContainsFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/CollectionFunctions/ContainsFunction.cs
@@ -6,6 +6,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.CollectionFunctions
 {
+    [FunctionRegistration("contains")]
     public class ContainsFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
@@ -44,4 +45,4 @@ public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] paramet
             }
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ExpressionEngine/Functions/Implementations/CollectionFunctions/EmptyFunction.cs b/ExpressionEngine/Functions/Implementations/CollectionFunctions/EmptyFunction.cs
index c1d76a3..862a497 100644
--- a/ExpressionEngine/Functions/Implementations/CollectionFunctions/EmptyFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/CollectionFunctions/EmptyFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.CollectionFunctions
 {
+    [FunctionRegistration("empty")]
     public class EmptyFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/CollectionFunctions/FirstFunction.cs b/ExpressionEngine/Functions/Implementations/CollectionFunctions/FirstFunction.cs
index 7702bda..b49aa17 100644
--- a/ExpressionEngine/Functions/Implementations/CollectionFunctions/FirstFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/CollectionFunctions/FirstFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.CollectionFunctions
 {
+    [FunctionRegistration("first")]
     public class FirstFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/CollectionFunctions/IntersectionFunction.cs b/ExpressionEngine/Functions/Implementations/CollectionFunctions/IntersectionFunction.cs
index 46e3e63..bfb6f0f 100644
--- a/ExpressionEngine/Functions/Implementations/CollectionFunctions/IntersectionFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/CollectionFunctions/IntersectionFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.CollectionFunctions
 {
+    [FunctionRegistration("intersection")]
     public class InterSectionFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/CollectionFunctions/JoinFunction.cs b/ExpressionEngine/Functions/Implementations/CollectionFunctions/JoinFunction.cs
index 5c60c70..5c6c3ed 100644
--- a/ExpressionEngine/Functions/Implementations/CollectionFunctions/JoinFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/CollectionFunctions/JoinFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.CollectionFunctions
 {
+    [FunctionRegistration("join")]
     public class JoinFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/CollectionFunctions/LastFunction.cs b/ExpressionEngine/Functions/Implementations/CollectionFunctions/LastFunction.cs
index 9b060b9..62268ae 100644
--- a/ExpressionEngine/Functions/Implementations/CollectionFunctions/LastFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/CollectionFunctions/LastFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.CollectionFunctions
 {
+    [FunctionRegistration("last")]
     public class LastFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/CollectionFunctions/SkipFunction.cs b/ExpressionEngine/Functions/Implementations/CollectionFunctions/SkipFunction.cs
index 1e42087..12ceff9 100644
--- a/ExpressionEngine/Functions/Implementations/CollectionFunctions/SkipFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/CollectionFunctions/SkipFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.CollectionFunctions
 {
+    [FunctionRegistration("skip")]
     public class SkipFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/CollectionFunctions/TakeFunction.cs b/ExpressionEngine/Functions/Implementations/CollectionFunctions/TakeFunction.cs
index 8f3b628..d6ef4f1 100644
--- a/ExpressionEngine/Functions/Implementations/CollectionFunctions/TakeFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/CollectionFunctions/TakeFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.CollectionFunctions
 {
+    [FunctionRegistration("take")]
     public class TakeFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/CollectionFunctions/UnionFunction.cs b/ExpressionEngine/Functions/Implementations/CollectionFunctions/UnionFunction.cs
index 9a7e88d..7126c31 100644
--- a/ExpressionEngine/Functions/Implementations/CollectionFunctions/UnionFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/CollectionFunctions/UnionFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.CollectionFunctions
 {
+    [FunctionRegistration("union")]
     public class UnionFunction : IFunction
     {
         public async ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/ConversionFunctions/ArrayFunction.cs b/ExpressionEngine/Functions/Implementations/ConversionFunctions/ArrayFunction.cs
index 50c7df7..52f0ab2 100644
--- a/ExpressionEngine/Functions/Implementations/ConversionFunctions/ArrayFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/ConversionFunctions/ArrayFunction.cs
@@ -3,6 +3,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.ConversionFunctions
 {
+    [FunctionRegistration("array")]
     public class ArrayFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/ConversionFunctions/Base64Function.cs b/ExpressionEngine/Functions/Implementations/ConversionFunctions/Base64Function.cs
index 0247989..dac8e4a 100644
--- a/ExpressionEngine/Functions/Implementations/ConversionFunctions/Base64Function.cs
+++ b/ExpressionEngine/Functions/Implementations/ConversionFunctions/Base64Function.cs
@@ -3,6 +3,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.ConversionFunctions
 {
+    [FunctionRegistration("base64")]
     public class Base64Function : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/ConversionFunctions/Base64ToBinaryFunction.cs b/ExpressionEngine/Functions/Implementations/ConversionFunctions/Base64ToBinaryFunction.cs
index 1e1190d..9e23eeb 100644
--- a/ExpressionEngine/Functions/Implementations/ConversionFunctions/Base64ToBinaryFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/ConversionFunctions/Base64ToBinaryFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.ConversionFunctions
 {
+    [FunctionRegistration("base64ToBinary")]
     public class Base64ToBinaryFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/ConversionFunctions/Base64ToStringFunction.cs b/ExpressionEngine/Functions/Implementations/ConversionFunctions/Base64ToStringFunction.cs
index c15ca9a..43050e8 100644
--- a/ExpressionEngine/Functions/Implementations/ConversionFunctions/Base64ToStringFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/ConversionFunctions/Base64ToStringFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.ConversionFunctions
 {
+    [FunctionRegistration("base64ToString")]
     public class Base64ToStringFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
@@ -12,10 +13,11 @@ public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] paramet
             return parameters[0].Type() switch
             {
                 ValueType.String =>
-                    new ValueTask<ValueContainer>(new ValueContainer(Encoding.UTF8.GetString(Convert.FromBase64String(parameters[0].GetValue<string>())))),
+                    new ValueTask<ValueContainer>(new ValueContainer(
+                        Encoding.UTF8.GetString(Convert.FromBase64String(parameters[0].GetValue<string>())))),
                 _ => throw new ExpressionEngineException(
                     $"Array function can only operate on strings, not {parameters[0].Type()}.")
             };
         }
     }
-}
+}
\ No newline at end of file
diff --git a/ExpressionEngine/Functions/Implementations/ConversionFunctions/BinaryFunction.cs b/ExpressionEngine/Functions/Implementations/ConversionFunctions/BinaryFunction.cs
index 3599899..8ec32c2 100644
--- a/ExpressionEngine/Functions/Implementations/ConversionFunctions/BinaryFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/ConversionFunctions/BinaryFunction.cs
@@ -6,6 +6,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.ConversionFunctions
 {
+    [FunctionRegistration("binary")]
     public class BinaryFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/ConversionFunctions/BoolFunction.cs b/ExpressionEngine/Functions/Implementations/ConversionFunctions/BoolFunction.cs
index 875b7f8..43c5f00 100644
--- a/ExpressionEngine/Functions/Implementations/ConversionFunctions/BoolFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/ConversionFunctions/BoolFunction.cs
@@ -3,6 +3,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.ConversionFunctions
 {
+    [FunctionRegistration("bool")]
     public class BoolFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/ConversionFunctions/CreateArrayFunction.cs b/ExpressionEngine/Functions/Implementations/ConversionFunctions/CreateArrayFunction.cs
index afae1b6..08bdeed 100644
--- a/ExpressionEngine/Functions/Implementations/ConversionFunctions/CreateArrayFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/ConversionFunctions/CreateArrayFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.ConversionFunctions
 {
+    [FunctionRegistration("createArray")]
     public class CreateArrayFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/ConversionFunctions/DataUriFunction.cs b/ExpressionEngine/Functions/Implementations/ConversionFunctions/DataUriFunction.cs
index 6634dbe..bf0cc60 100644
--- a/ExpressionEngine/Functions/Implementations/ConversionFunctions/DataUriFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/ConversionFunctions/DataUriFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.ConversionFunctions
 {
+    [FunctionRegistration("dataUri")]
     public class DataUriFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/ConversionFunctions/DataUriToBinaryFunction.cs b/ExpressionEngine/Functions/Implementations/ConversionFunctions/DataUriToBinaryFunction.cs
index 4cff995..95f119c 100644
--- a/ExpressionEngine/Functions/Implementations/ConversionFunctions/DataUriToBinaryFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/ConversionFunctions/DataUriToBinaryFunction.cs
@@ -7,6 +7,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.ConversionFunctions
 {
+    [FunctionRegistration("dataUriToBinary")]
     public class DataUriToBinaryFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/ConversionFunctions/FloatFunction.cs b/ExpressionEngine/Functions/Implementations/ConversionFunctions/FloatFunction.cs
index 45c7264..a9b32d1 100644
--- a/ExpressionEngine/Functions/Implementations/ConversionFunctions/FloatFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/ConversionFunctions/FloatFunction.cs
@@ -1,10 +1,10 @@
-using System;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using ExpressionEngine.Functions.Base;
 using ExpressionEngine.Functions.CustomException;
 
 namespace ExpressionEngine.Functions.Implementations.ConversionFunctions
 {
+    [FunctionRegistration("float")]
     public class FloatFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/ConversionFunctions/IntFunction.cs b/ExpressionEngine/Functions/Implementations/ConversionFunctions/IntFunction.cs
index 667b115..4fc5974 100644
--- a/ExpressionEngine/Functions/Implementations/ConversionFunctions/IntFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/ConversionFunctions/IntFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.ConversionFunctions
 {
+    [FunctionRegistration("int")]
     public class IntFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/AndFunction.cs b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/AndFunction.cs
index 8747070..b8834bb 100644
--- a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/AndFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/AndFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.LogicalComparisonFunctions
 {
+    [FunctionRegistration("and")]
     public class AndFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/EqualFunction.cs b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/EqualFunction.cs
index bc5a98d..370b218 100644
--- a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/EqualFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/EqualFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.LogicalComparisonFunctions
 {
+    [FunctionRegistration("equal")]
     public class EqualFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/GreaterFunction.cs b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/GreaterFunction.cs
index 30cf863..833b3c6 100644
--- a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/GreaterFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/GreaterFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.LogicalComparisonFunctions
 {
+    [FunctionRegistration("greater")]
     public class GreaterFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/GreaterOrEqualsFunction.cs b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/GreaterOrEqualsFunction.cs
index 26aa6f5..e59ca22 100644
--- a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/GreaterOrEqualsFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/GreaterOrEqualsFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.LogicalComparisonFunctions
 {
+    [FunctionRegistration("geraterOrEquals")]
     public class GreaterOrEqualsFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/IfFunction.cs b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/IfFunction.cs
index 4fa0f87..ca8c5e5 100644
--- a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/IfFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/IfFunction.cs
@@ -3,6 +3,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.LogicalComparisonFunctions
 {
+    [FunctionRegistration("if")]
     public class IfFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/LessFunction.cs b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/LessFunction.cs
index 79a35fb..c708a37 100644
--- a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/LessFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/LessFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.LogicalComparisonFunctions
 {
+    [FunctionRegistration("less")]
     public class LessFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/LessOrEqualsFunction.cs b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/LessOrEqualsFunction.cs
index 52778d1..4b8e2a0 100644
--- a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/LessOrEqualsFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/LessOrEqualsFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.LogicalComparisonFunctions
 {
+    [FunctionRegistration("lessOrEquals")]
     public class LessOrEqualsFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/NotFunction.cs b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/NotFunction.cs
index 3262e5e..e724a4d 100644
--- a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/NotFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/NotFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.LogicalComparisonFunctions
 {
+    [FunctionRegistration("not")]
     public class NotFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/OrFunction.cs b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/OrFunction.cs
index f91b02e..4c994aa 100644
--- a/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/OrFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/LogicalComparisonFunctions/OrFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.LogicalComparisonFunctions
 {
+    [FunctionRegistration("or")]
     public class OrFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/Math/AddFunction.cs b/ExpressionEngine/Functions/Implementations/Math/AddFunction.cs
index 280e2f9..cbc82f3 100644
--- a/ExpressionEngine/Functions/Implementations/Math/AddFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/Math/AddFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Math
 {
+    [FunctionRegistration("add")]
     public class AddFunction : IFunction
     {
         /// <functionName>add</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/Math/DivFunction.cs b/ExpressionEngine/Functions/Implementations/Math/DivFunction.cs
index 7eecab4..4f232c4 100644
--- a/ExpressionEngine/Functions/Implementations/Math/DivFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/Math/DivFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Math
 {
+    [FunctionRegistration("div")]
     public class DivFunction : IFunction
     {
         /// <functionName>div</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/Math/MaxFunction.cs b/ExpressionEngine/Functions/Implementations/Math/MaxFunction.cs
index 6171012..d822fae 100644
--- a/ExpressionEngine/Functions/Implementations/Math/MaxFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/Math/MaxFunction.cs
@@ -6,6 +6,7 @@
 
 namespace ExpressionEngine.Functions.Math
 {
+    [FunctionRegistration("max")]
     public class MaxFunction : IFunction
     {
         /// <functionName>max</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/Math/MinFunction.cs b/ExpressionEngine/Functions/Implementations/Math/MinFunction.cs
index af30857..a5d30f3 100644
--- a/ExpressionEngine/Functions/Implementations/Math/MinFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/Math/MinFunction.cs
@@ -6,6 +6,7 @@
 
 namespace ExpressionEngine.Functions.Math
 {
+    [FunctionRegistration("min")]
     public class MinFunction : IFunction
     {
         /// <functionName>min</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/Math/ModFunction.cs b/ExpressionEngine/Functions/Implementations/Math/ModFunction.cs
index 6211102..1060e6c 100644
--- a/ExpressionEngine/Functions/Implementations/Math/ModFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/Math/ModFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Math
 {
+    [FunctionRegistration("mod")]
     public class ModFunction : IFunction
     {
         /// <functionName>mod</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/Math/MulFunction.cs b/ExpressionEngine/Functions/Implementations/Math/MulFunction.cs
index f26dadf..5616db6 100644
--- a/ExpressionEngine/Functions/Implementations/Math/MulFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/Math/MulFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Math
 {
+    [FunctionRegistration("mul")]
     public class MulFunction : IFunction
     {
         /// <functionName>mul</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/Math/RandFunction.cs b/ExpressionEngine/Functions/Implementations/Math/RandFunction.cs
index 4446571..1eeb0d4 100644
--- a/ExpressionEngine/Functions/Implementations/Math/RandFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/Math/RandFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Math
 {
+    [FunctionRegistration("rand")]
     public class RandFunction : IFunction
     {
         /// <functionName>rand</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/Math/RangeFunction.cs b/ExpressionEngine/Functions/Implementations/Math/RangeFunction.cs
index d5b4112..a1510da 100644
--- a/ExpressionEngine/Functions/Implementations/Math/RangeFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/Math/RangeFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Math
 {
+    [FunctionRegistration("range")]
     public class RangeFunction : IFunction
     {
         /// <functionName>range</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/Math/SubFunction.cs b/ExpressionEngine/Functions/Implementations/Math/SubFunction.cs
index e8bcb49..01e3c7a 100644
--- a/ExpressionEngine/Functions/Implementations/Math/SubFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/Math/SubFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Math
 {
+    [FunctionRegistration("sub")]
     public class SubFunction : IFunction
     {
         /// <functionName>sub</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/ConcatFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/ConcatFunction.cs
index 39458e7..5431140 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/ConcatFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/ConcatFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("concat")]
     public class ConcatFunction : IFunction
     {
         /// <functionName>concat</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/EndsWithFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/EndsWithFunction.cs
index cb6c93f..2115cf1 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/EndsWithFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/EndsWithFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("endsWith")]
     public class EndsWithFunction : IFunction
     {
         /// <functionName>endsWith</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/FormatNumberFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/FormatNumberFunction.cs
index 341ae7c..077fa2d 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/FormatNumberFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/FormatNumberFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("formatNumber")]
     public class FormatNumberFunction : IFunction
     {
         /// <functionName>formatNumber</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/GuidFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/GuidFunction.cs
index 4ef3641..de8b4dc 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/GuidFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/GuidFunction.cs
@@ -6,6 +6,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("guid")]
     public class GuidFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/IndexOfFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/IndexOfFunction.cs
index 338aa83..59ee0ac 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/IndexOfFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/IndexOfFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("indexOf")]
     public class IndexOfFunction : IFunction
     {
         public  ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/LastIndexOfFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/LastIndexOfFunction.cs
index 8ad0432..321ad3d 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/LastIndexOfFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/LastIndexOfFunction.cs
@@ -5,6 +5,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("lastIndexOf")]
     public class LastIndexOfFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/LengthFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/LengthFunction.cs
index f836986..7ec45f6 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/LengthFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/LengthFunction.cs
@@ -7,6 +7,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("length")]
     public class LengthFunction : IFunction
     {
         /// <functionName>length</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/ReplaceFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/ReplaceFunction.cs
index 9c40584..c033b7f 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/ReplaceFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/ReplaceFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("replace")]
     public class ReplaceFunction : IFunction
     {
         /// <functionName>replace</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/SplitFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/SplitFunction.cs
index 7ea04a1..f090320 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/SplitFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/SplitFunction.cs
@@ -6,6 +6,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("split")]
     public class SplitFunction : IFunction
     {
         /// <functionName>split</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/StartsWithFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/StartsWithFunction.cs
index d965106..1649ce6 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/StartsWithFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/StartsWithFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("startsWith")]
     public class StartsWithFunction : IFunction
     {
         /// <functionName>startsWith</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/SubstringFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/SubstringFunction.cs
index 2b4c01a..68001e6 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/SubstringFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/SubstringFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("substring")]
     public class SubstringFunction : IFunction
     {
         /// <functionName>substring</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/ToLowerFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/ToLowerFunction.cs
index acf7b4e..24db9ef 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/ToLowerFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/ToLowerFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("toLower")]
     public class ToLowerFunction : IFunction
     {
         /// <functionName>toLower</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/ToUpperFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/ToUpperFunction.cs
index d43d528..575b789 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/ToUpperFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/ToUpperFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("toUpper")]
     public class ToUpperFunction : IFunction
     {
         /// <functionName>toUpper</functionName>
diff --git a/ExpressionEngine/Functions/Implementations/StringFunctions/TrimFunction.cs b/ExpressionEngine/Functions/Implementations/StringFunctions/TrimFunction.cs
index 3b6558c..59c3a60 100644
--- a/ExpressionEngine/Functions/Implementations/StringFunctions/TrimFunction.cs
+++ b/ExpressionEngine/Functions/Implementations/StringFunctions/TrimFunction.cs
@@ -4,6 +4,7 @@
 
 namespace ExpressionEngine.Functions.Implementations.StringFunctions
 {
+    [FunctionRegistration("trim")]
     public class TrimFunction : IFunction
     {
         public ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
diff --git a/ExpressionEngine/Rules/StringLiteralRule.cs b/ExpressionEngine/Rules/StringLiteralRule.cs
index 13cd606..6bed784 100644
--- a/ExpressionEngine/Rules/StringLiteralRule.cs
+++ b/ExpressionEngine/Rules/StringLiteralRule.cs
@@ -2,20 +2,27 @@
 
 namespace ExpressionEngine.Rules
 {
+    /// <inheritdoc />
     public class StringLiteralRule : IRule
     {
         private readonly ValueContainer _content;
 
+        /// <summary>
+        /// Represents string literals, i.e. <code>'Hello World!'</code>
+        /// </summary>
+        /// <param name="content">String value</param>
         public StringLiteralRule(ValueContainer content)
         {
             _content = content;
         }
 
+        /// <inheritdoc />
         public ValueTask<ValueContainer> Evaluate()
         {
             return new ValueTask<ValueContainer>(_content);
         }
 
+        /// <inheritdoc />
         public string PrettyPrint()
         {
             return $"'{_content}'";
diff --git a/ExpressionEngine/Scope.cs b/ExpressionEngine/Scope.cs
new file mode 100644
index 0000000..b257634
--- /dev/null
+++ b/ExpressionEngine/Scope.cs
@@ -0,0 +1,23 @@
+namespace ExpressionEngine
+{
+    /// <summary>
+    /// Representing the scopes available for dependency injection
+    /// </summary>
+    public enum Scope
+    {
+        /// <summary>
+        /// Scoped
+        /// </summary>
+        Scoped,
+
+        /// <summary>
+        /// Transient
+        /// </summary>
+        Transient,
+
+        /// <summary>
+        /// Singleton
+        /// </summary>
+        Singleton
+    }
+}
\ No newline at end of file
diff --git a/ExpressionEngine/ValueContainer.cs b/ExpressionEngine/ValueContainer.cs
index bf151f2..f107b2e 100644
--- a/ExpressionEngine/ValueContainer.cs
+++ b/ExpressionEngine/ValueContainer.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
@@ -18,6 +17,16 @@ public class ValueContainer : IComparable, IEquatable<ValueContainer>
         private readonly object _value;
         private readonly ValueType _type;
 
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="value"></param>
+        /// <returns></returns>
+        public static implicit operator ValueContainer(string value)
+        {
+            return new ValueContainer(value);
+        }
+        
         /// <summary>
         /// Creates Value Container from string
         /// </summary>
@@ -62,60 +71,100 @@ public ValueContainer(string value, bool tryToParse = false)
             }
         }
 
+        /// <summary>
+        /// Construct string ValueContainer
+        /// </summary>
+        /// <param name="stringValue">ValueContainer content</param>
         public ValueContainer(string stringValue)
         {
             _value = stringValue;
             _type = ValueType.String;
         }
 
+        /// <summary>
+        /// Construct Guid ValueContainer
+        /// </summary>
+        /// <param name="guid">ValueContainer content</param>
         public ValueContainer(Guid guid)
         {
             _value = guid;
             _type = ValueType.Guid;
         }
 
+        /// <summary>
+        /// Construct Date ValueContainer
+        /// </summary>
+        /// <param name="dateTime">ValueContainer content</param>
         public ValueContainer(DateTimeOffset dateTime)
         {
             _value = dateTime;
             _type = ValueType.Date;
         }
 
+        /// <summary>
+        /// Construct decimal ValueContainer from float
+        /// </summary>
+        /// <param name="floatValue">ValueContainer content</param>
         public ValueContainer(float floatValue)
         {
             _value = Convert.ToDecimal(floatValue);
             _type = ValueType.Float;
         }
 
+        /// <summary>
+        /// Construct decimal ValueContainer
+        /// </summary>
+        /// <param name="floatValue">ValueContainer content</param>
         public ValueContainer(decimal floatValue)
         {
             _value = floatValue;
             _type = ValueType.Float;
         }
 
+        /// <summary>
+        /// Construct float ValueContainer from double
+        /// </summary>
+        /// <param name="floatValue">ValueContainer content</param>
         public ValueContainer(double floatValue)
         {
             _value = Convert.ToDecimal(floatValue);
             _type = ValueType.Float;
         }
 
+        /// <summary>
+        /// Construct int ValueContainer
+        /// </summary>
+        /// <param name="intValue">ValueContainer content</param>
         public ValueContainer(int intValue)
         {
             _value = intValue;
             _type = ValueType.Integer;
         }
 
+        /// <summary>
+        /// Construct boolean ValueContainer
+        /// </summary>
+        /// <param name="boolValue">ValueContainer content</param>
         public ValueContainer(bool boolValue)
         {
             _value = boolValue;
             _type = ValueType.Boolean;
         }
 
+        /// <summary>
+        /// Construct Array ValueContainer
+        /// </summary>
+        /// <param name="arrayValue">ValueContainer content</param>
         public ValueContainer(List<ValueContainer> arrayValue)
         {
             _value = arrayValue;
             _type = ValueType.Array;
         }
 
+        /// <summary>
+        /// Construct Array ValueContainer
+        /// </summary>
+        /// <param name="arrayValue">ValueContainer content</param>
         public ValueContainer(IEnumerable<ValueContainer> arrayValue)
         {
             _value = arrayValue.ToList();
@@ -129,29 +178,48 @@ internal ValueContainer(Dictionary<string, ValueContainer> objectValue, bool nor
             _type = ValueType.Object;
         }
 
+        /// <summary>
+        /// Construct Object ValueContainer
+        /// </summary>
+        /// <param name="objectValue">ValueContainer content</param>
         public ValueContainer(Dictionary<string, ValueContainer> objectValue)
         {
             _value = objectValue.Normalize();
             _type = ValueType.Object;
         }
 
+        /// <summary>
+        /// Construct ValueContainer copied from another ValueContainer
+        /// </summary>
+        /// <param name="valueContainer">ValueContainer content</param>
         public ValueContainer(ValueContainer valueContainer)
         {
             _type = valueContainer._type;
             _value = valueContainer._value;
         }
 
+        /// <summary>
+        /// Construct Null ValueContainer
+        /// </summary>
         public ValueContainer()
         {
             _type = ValueType.Null;
             _value = null;
         }
 
+        /// <summary>
+        /// Type of the value within the ValueContainer
+        /// </summary>
+        /// <returns></returns>
         public ValueType Type()
         {
             return _type;
         }
 
+        /// <summary>
+        /// Check if value in ValueContainer is a number
+        /// </summary>
+        /// <returns>true if number else false</returns>
         public bool IsNumber()
         {
             return _type == ValueType.Float || _type == ValueType.Integer;
@@ -196,6 +264,11 @@ public T GetValue<T>()
                 $"Cannot convert ValueContainer of type {_value.GetType()} to {typeof(T)}");
         }
 
+        /// <summary>
+        /// Access i'th element of array
+        /// </summary>
+        /// <param name="i">index</param>
+        /// <exception cref="InvalidOperationException">Is thrown is this is not an array</exception>
         public ValueContainer this[int i]
         {
             get
@@ -218,6 +291,11 @@ public ValueContainer this[int i]
             }
         }
 
+        /// <summary>
+        /// Access element in object by key
+        /// </summary>
+        /// <param name="key">key of element tor retrieve</param>
+        /// <exception cref="InvalidOperationException">Is thrown is this is not an object</exception>
         public ValueContainer this[string key]
         {
             get
@@ -268,6 +346,11 @@ public ValueContainer this[string key]
             }
         }
 
+        /// <summary>
+        /// Return value of ValueContainer as Dictionary
+        /// </summary>
+        /// <returns>Value as Dictionary</returns>
+        /// <exception cref="ExpressionEngineException">Is thrown is this is not an Object</exception>
         public Dictionary<string, ValueContainer> AsDict()
         {
             if (_type == ValueType.Object)
@@ -278,6 +361,11 @@ public Dictionary<string, ValueContainer> AsDict()
             throw new ExpressionEngineException("Can't get none object value container as dict.");
         }
 
+        /// <summary>
+        /// Return value of ValueCOntianer as List
+        /// </summary>
+        /// <returns>Value as List</returns>
+        /// <exception cref="ExpressionEngineException">Is thrown is this is not an Array</exception>
         public List<ValueContainer> AsList()
         {
             if (_type == ValueType.Array)
@@ -311,11 +399,16 @@ public override string ToString()
             };
         }
 
+        /// <summary>
+        /// Check if ValueContainer is of type null
+        /// </summary>
+        /// <returns>boolean</returns>
         public bool IsNull()
         {
             return _type == ValueType.Null;
         }
 
+        /// <inheritdoc />
         public int CompareTo(object? obj)
         {
             if (obj == null || obj.GetType() != GetType())
@@ -353,6 +446,7 @@ public int CompareTo(object? obj)
             }
         }
 
+        /// <inheritdoc />
         public bool Equals(ValueContainer other)
         {
             if (ReferenceEquals(null, other)) return false;
@@ -384,6 +478,7 @@ public bool Equals(ValueContainer other)
             }
         }
 
+        /// <inheritdoc />
         public override bool Equals(object obj)
         {
             if (ReferenceEquals(null, obj)) return false;
@@ -391,11 +486,19 @@ public override bool Equals(object obj)
             return obj.GetType() == GetType() && Equals((ValueContainer) obj);
         }
 
+        /// <inheritdoc />
         public override int GetHashCode()
         {
             return new {_type, _value}.GetHashCode();
         }
 
+        /// <summary>
+        /// Check if ValueContainer of type Object contains the given key
+        ///
+        /// Key is split according to '/'
+        /// </summary>
+        /// <param name="key">key or path</param>
+        /// <returns>boolean</returns>
         public bool ContainsKey(string key)
         {
             if (_type != ValueType.Object) return false;
diff --git a/Test/NullCoalescingTest.cs b/Test/NullCoalescingTest.cs
index 33ec23e..7bd3168 100644
--- a/Test/NullCoalescingTest.cs
+++ b/Test/NullCoalescingTest.cs
@@ -20,7 +20,7 @@ private IServiceProvider BuildServiceProvider()
             {
                 var services = new ServiceCollection();
                 services.AddExpressionEngine();
-                services.RegisterScopedFunctionAlias<VariablesFunction>("variables");
+                services.BuildFunction<VariablesFunction>().WithAlias("variables").AsScoped().Add();
                 _serviceProvider = services.BuildServiceProvider();
             }
 
diff --git a/Test/NullCoalescingTest2.cs b/Test/NullCoalescingTest2.cs
index b6abe90..a64c929 100644
--- a/Test/NullCoalescingTest2.cs
+++ b/Test/NullCoalescingTest2.cs
@@ -20,6 +20,7 @@ public void Setup()
             t.RegisterTransientFunctionAlias<DummyFunction>("dummy");
             _returnData = new ReturnData();
             t.RegisterScopedFunctionAlias("returnData", _ => _returnData);
+            t.RegisterScopedFunctionAlias("returnData", _ => _returnData);
             t.BuildServiceProvider().GetService<IExpressionEngine>();
 
             t.AddSingleton<ExpressionGrammar>();
diff --git a/Test/ParserTest.cs b/Test/ParserTest.cs
index 05e3f92..4550c11 100644
--- a/Test/ParserTest.cs
+++ b/Test/ParserTest.cs
@@ -14,11 +14,12 @@ public class AsynctestFunction : IFunction
     {
         public async ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
         {
-            await Task.Delay((int) (new Random().NextDouble()* 10000));
+            await Task.Delay((int) (new Random().NextDouble() * 10000));
             return new ValueContainer("Hello World");
         }
     }
-    
+
+    [FunctionRegistration("asynctest")]
     public class NonExistingFunction1 : IFunction
     {
         public async ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] parameters)
@@ -27,7 +28,7 @@ public async ValueTask<ValueContainer> ExecuteFunction(params ValueContainer[] p
         }
     }
 
-    
+
     [TestFixture]
     public class ParserTest
     {
@@ -35,8 +36,8 @@ private ServiceProvider BuildServiceProvider()
         {
             var services = new ServiceCollection();
             services.AddExpressionEngine();
-            services.RegisterTransientFunctionAlias<AsynctestFunction>("asynctest");
-            services.AddSingleton(_ => new FunctionMetadata(typeof(NonExistingFunction1),"nonExistingFunction1"));
+            services.AddFunction<AsynctestFunction>();
+            services.AddSingleton(_ => new FunctionMetadata(typeof(NonExistingFunction1), "nonExistingFunction1"));
             return services.BuildServiceProvider();
         }
 
@@ -95,8 +96,8 @@ public async Task TestSimpleInput(TestInput testInput)
                 new ValueContainer("Just a simple string without an exceptions")),
             new TestInput("tst@delegate.dk", new ValueContainer("tst@delegate.dk")),
             new TestInput(
-                "@{toLower(\'user@DOMAIN.dk\')} - Send me an email or call on 8888 8888!", new ValueContainer(
-                    "user@domain.dk - Send me an email or call on 8888 8888!")
+                "Email: @{toLower(\'user@DOMAIN.dk\')} - Send me an email or call on 8888 8888!", new ValueContainer(
+                    "Email: user@domain.dk - Send me an email or call on 8888 8888!")
             ),
             new TestInput("@concat(\'Hi you,\',\' Alice B.\')", new ValueContainer("Hi you, Alice B.")),
             new TestInput(
@@ -114,8 +115,6 @@ public async Task TestSimpleInput(TestInput testInput)
             new TestInput("@greater(10.1, 10.0)", new ValueContainer(true)),
             new TestInput("@greater(10.1, 10)", new ValueContainer(true)),
             new TestInput("@add(10,0.5)", new ValueContainer(10.5)),
-            
-
         };
 
         #endregion
@@ -137,7 +136,6 @@ public async Task TestAsync(TestInput testInput)
                 new ValueContainer("Hello World - Hello World - Hello World")),
         };
 
-     
 
         public class TestInput
         {
@@ -146,6 +144,7 @@ public TestInput(string input, ValueContainer expectedOutput)
                 Input = input;
                 ExpectedOutput = expectedOutput;
             }
+
             public ValueContainer[] ValueContainers { get; set; }
             public string Input { get; set; }
             public ValueContainer ExpectedOutput { get; set; }