From a2bec33dc3a8514c65c60df8396578e70b311cfe Mon Sep 17 00:00:00 2001
From: Martin <mautner@vrvis.at>
Date: Tue, 20 Aug 2024 16:20:46 +0200
Subject: [PATCH] [FSharp] Optimize and rework type patterns

---
 .../Aardvark.Base.FSharp.fsproj               |   2 +
 src/Aardvark.Base.FSharp/Ag.fs                |   1 -
 .../Reflection/TypeInfo.fs                    |  67 +---
 .../Reflection/TypeMeta_auto.fs               | 309 ++++++++++++++++++
 .../Reflection/TypeMeta_template.fs           | 197 +++++++++++
 src/Aardvark.Base.FSharp/Runtime/Fragments.fs |   2 +-
 src/Aardvark.Base/AlgoDat/Meta.cs             |  16 +
 .../Aardvark.Base.FSharp.Benchmarks.fsproj    |   1 +
 .../TypePatternsBench.fs                      |  99 ++++++
 .../Aardvark.Base.FSharp.Tests.fsproj         |   1 +
 .../TypePatternsTests.fs                      |  50 +++
 11 files changed, 689 insertions(+), 56 deletions(-)
 create mode 100644 src/Aardvark.Base.FSharp/Reflection/TypeMeta_auto.fs
 create mode 100644 src/Aardvark.Base.FSharp/Reflection/TypeMeta_template.fs
 create mode 100644 src/Tests/Aardvark.Base.FSharp.Benchmarks/TypePatternsBench.fs
 create mode 100644 src/Tests/Aardvark.Base.FSharp.Tests/TypePatternsTests.fs

diff --git a/src/Aardvark.Base.FSharp/Aardvark.Base.FSharp.fsproj b/src/Aardvark.Base.FSharp/Aardvark.Base.FSharp.fsproj
index 205813f29..b8baa2b35 100644
--- a/src/Aardvark.Base.FSharp/Aardvark.Base.FSharp.fsproj
+++ b/src/Aardvark.Base.FSharp/Aardvark.Base.FSharp.fsproj
@@ -60,6 +60,8 @@
     <Compile Include="Color\ColorBrewer.fs" />
     <Compile Include="Color\ColorBrewerSchemes.fs" />
     <None Include="color\ColorBrewerSchemes.fsx" />
+    <None Include="Reflection\TypeMeta_template.fs" />
+    <Compile Include="Reflection\TypeMeta_auto.fs" />
     <Compile Include="Reflection\TypeInfo.fs" />
     <Compile Include="Reflection\FunctionReflection.fs" />
     <Compile Include="Reflection\Formatf.fs" />
diff --git a/src/Aardvark.Base.FSharp/Ag.fs b/src/Aardvark.Base.FSharp/Ag.fs
index b124b15ad..4eedeb088 100644
--- a/src/Aardvark.Base.FSharp/Ag.fs
+++ b/src/Aardvark.Base.FSharp/Ag.fs
@@ -234,7 +234,6 @@ module Ag =
     [<AutoOpen>]
     module private Helpers =
         open System.Reflection.Emit
-        open Aardvark.Base.TypeInfo
 
         type NewRootDelegate = delegate of obj -> obj
         type SynDelegateStatic = delegate of obj * Scope -> obj
diff --git a/src/Aardvark.Base.FSharp/Reflection/TypeInfo.fs b/src/Aardvark.Base.FSharp/Reflection/TypeInfo.fs
index aae8d4378..3a8221bb1 100644
--- a/src/Aardvark.Base.FSharp/Reflection/TypeInfo.fs
+++ b/src/Aardvark.Base.FSharp/Reflection/TypeInfo.fs
@@ -9,6 +9,7 @@ namespace Aardvark.Base
 /// TypeInfo contains metadata associated with types and provides active patterns
 /// deconstructing vector/matrix types etc.
 /// </summary>
+[<System.Obsolete("Use TypeMeta module instead.")>]
 module TypeInfo =
     open System
     open System.Collections.Generic
@@ -266,93 +267,51 @@ module TypeInfo =
 
         [<return: Struct>]
         let inline (|Integral|_|) (t : Type) =
-            if Set.contains (typeInfo t) IntegralTypes then
-                ValueSome ()
-            else
-                ValueNone
+            TypeMeta.Patterns.(|Integral|_|) t
 
         [<return: Struct>]
         let inline (|Fractional|_|) (t : Type) =
-            if Set.contains (typeInfo t) FractionalTypes then
-                ValueSome ()
-            else
-                ValueNone
+            TypeMeta.Patterns.(|Fractional|_|) t
 
         [<return: Struct>]
         let inline (|Num|_|) (t : Type) =
-            if Set.contains (typeInfo t) NumTypes then
-                ValueSome ()
-            else
-                ValueNone
+            TypeMeta.Patterns.(|Numeric|_|) t
 
         [<return: Struct>]
         let inline (|Vector|_|) (t : Type) =
-            if Set.contains (typeInfo t) VectorTypes then
-                ValueSome ()
-            else
-                ValueNone
+            TypeMeta.Patterns.(|Vector|_|) t
 
         [<return: Struct>]
         let inline (|Color|_|) (t : Type) =
-            if Set.contains (typeInfo t) ColorTypes then
-                ValueSome ()
-            else
-                ValueNone
+            TypeMeta.Patterns.(|Color|_|) t
 
         [<return: Struct>]
         let inline (|Matrix|_|) (t : Type) =
-            if Set.contains (typeInfo t) MatrixTypes then
-                ValueSome ()
-            else
-                ValueNone
+            TypeMeta.Patterns.(|Matrix|_|) t
 
         [<return: Struct>]
         let inline (|VectorOf|_|) (t : Type) =
-            VectorTypes
-            |> Seq.tryFindV (fun vi -> vi.Type.Name = t.Name)
-            |> ValueOption.map (fun t ->
-                let vt = unbox<VectorType> t
-                vt.dimension, vt.baseType.Type
-            )
+            TypeMeta.Patterns.(|VectorOf|_|) t |> ValueOption.map (fun struct (d, t) -> d, t)
 
         [<return: Struct>]
         let inline (|ColorOf|_|) (t : Type) =
-            ColorTypes
-            |> Seq.tryFindV (fun ti -> ti.Type.Name = t.Name)
-            |> ValueOption.map (fun t ->
-                let vt = unbox<VectorType> t
-                vt.dimension, vt.baseType.Type
-            )
+            TypeMeta.Patterns.(|ColorOf|_|) t |> ValueOption.map (fun struct (d, t) -> d, t)
 
         [<return: Struct>]
         let inline (|MatrixOf|_|) (t : Type) =
-            MatrixTypes
-            |> Seq.tryFindV (fun vi -> vi.Type.Name = t.Name)
-            |> ValueOption.map (fun t ->
-                let mt = unbox<MatrixType> t
-                mt.dimension, mt.baseType.Type
-            )
+            TypeMeta.Patterns.(|MatrixOf|_|) t |> ValueOption.map (fun struct (d, t) -> d, t)
 
         [<return: Struct>]
         let inline (|Ref|_|) (t : Type) =
-            if t.IsGenericType && t.GetGenericTypeDefinition() = TRef.simpleType then
-                ValueSome <| t.GetGenericArguments().[0]
-            else
-                ValueNone
+            TypeMeta.Patterns.(|RefOf|_|) t
 
         [<return: Struct>]
         let inline (|List|_|) (t : Type) =
-            if t.IsGenericType && t.GetGenericTypeDefinition() = TList.simpleType then
-                ValueSome <| t.GetGenericArguments().[0]
-            else
-                ValueNone
+            TypeMeta.Patterns.(|ListOf|_|) t
 
         [<return: Struct>]
         let inline (|Seq|_|) (t : Type) =
-            if t.IsGenericType && t.GetGenericTypeDefinition() = TSeq.simpleType then
-                ValueSome <| t.GetGenericArguments().[0]
-            else
-                ValueNone
+            TypeMeta.Patterns.(|SeqOf|_|) t
 
         [<Obsolete("Use Seq instead.")>]
         [<return: Struct>]
diff --git a/src/Aardvark.Base.FSharp/Reflection/TypeMeta_auto.fs b/src/Aardvark.Base.FSharp/Reflection/TypeMeta_auto.fs
new file mode 100644
index 000000000..f625047eb
--- /dev/null
+++ b/src/Aardvark.Base.FSharp/Reflection/TypeMeta_auto.fs
@@ -0,0 +1,309 @@
+namespace Aardvark.Base
+
+open System
+
+/// Contains metadata associated with types and provides active patterns deconstructing vector/matrix types etc.
+module TypeMeta =
+
+    [<Struct>]
+    type VectorType =
+        {
+            Type      : Type
+            FieldType : Type
+            Dimension : int
+        }
+
+    [<Struct>]
+    type MatrixType =
+        {
+            Type      : Type
+            FieldType : Type
+            Dimension : V2i
+        }
+
+    let VectorTypes : VectorType list =
+        [
+            { Type = typeof<V2i>; FieldType = typeof<int32>; Dimension = 2 }
+            { Type = typeof<V2ui>; FieldType = typeof<uint32>; Dimension = 2 }
+            { Type = typeof<V2l>; FieldType = typeof<int64>; Dimension = 2 }
+            { Type = typeof<V2f>; FieldType = typeof<float32>; Dimension = 2 }
+            { Type = typeof<V2d>; FieldType = typeof<float>; Dimension = 2 }
+            { Type = typeof<V3i>; FieldType = typeof<int32>; Dimension = 3 }
+            { Type = typeof<V3ui>; FieldType = typeof<uint32>; Dimension = 3 }
+            { Type = typeof<V3l>; FieldType = typeof<int64>; Dimension = 3 }
+            { Type = typeof<V3f>; FieldType = typeof<float32>; Dimension = 3 }
+            { Type = typeof<V3d>; FieldType = typeof<float>; Dimension = 3 }
+            { Type = typeof<V4i>; FieldType = typeof<int32>; Dimension = 4 }
+            { Type = typeof<V4ui>; FieldType = typeof<uint32>; Dimension = 4 }
+            { Type = typeof<V4l>; FieldType = typeof<int64>; Dimension = 4 }
+            { Type = typeof<V4f>; FieldType = typeof<float32>; Dimension = 4 }
+            { Type = typeof<V4d>; FieldType = typeof<float>; Dimension = 4 }
+        ]
+
+    let ColorTypes : VectorType list =
+        [
+            { Type = typeof<C3b>; FieldType = typeof<uint8>; Dimension = 3 }
+            { Type = typeof<C3us>; FieldType = typeof<uint16>; Dimension = 3 }
+            { Type = typeof<C3ui>; FieldType = typeof<uint32>; Dimension = 3 }
+            { Type = typeof<C3f>; FieldType = typeof<float32>; Dimension = 3 }
+            { Type = typeof<C3d>; FieldType = typeof<float>; Dimension = 3 }
+            { Type = typeof<C4b>; FieldType = typeof<uint8>; Dimension = 4 }
+            { Type = typeof<C4us>; FieldType = typeof<uint16>; Dimension = 4 }
+            { Type = typeof<C4ui>; FieldType = typeof<uint32>; Dimension = 4 }
+            { Type = typeof<C4f>; FieldType = typeof<float32>; Dimension = 4 }
+            { Type = typeof<C4d>; FieldType = typeof<float>; Dimension = 4 }
+        ]
+
+    let MatrixTypes : MatrixType list =
+        [
+            { Type = typeof<M22i>; FieldType = typeof<int32>; Dimension = V2i(2, 2) }
+            { Type = typeof<M22l>; FieldType = typeof<int64>; Dimension = V2i(2, 2) }
+            { Type = typeof<M22f>; FieldType = typeof<float32>; Dimension = V2i(2, 2) }
+            { Type = typeof<M22d>; FieldType = typeof<float>; Dimension = V2i(2, 2) }
+            { Type = typeof<M23i>; FieldType = typeof<int32>; Dimension = V2i(3, 2) }
+            { Type = typeof<M23l>; FieldType = typeof<int64>; Dimension = V2i(3, 2) }
+            { Type = typeof<M23f>; FieldType = typeof<float32>; Dimension = V2i(3, 2) }
+            { Type = typeof<M23d>; FieldType = typeof<float>; Dimension = V2i(3, 2) }
+            { Type = typeof<M33i>; FieldType = typeof<int32>; Dimension = V2i(3, 3) }
+            { Type = typeof<M33l>; FieldType = typeof<int64>; Dimension = V2i(3, 3) }
+            { Type = typeof<M33f>; FieldType = typeof<float32>; Dimension = V2i(3, 3) }
+            { Type = typeof<M33d>; FieldType = typeof<float>; Dimension = V2i(3, 3) }
+            { Type = typeof<M34i>; FieldType = typeof<int32>; Dimension = V2i(4, 3) }
+            { Type = typeof<M34l>; FieldType = typeof<int64>; Dimension = V2i(4, 3) }
+            { Type = typeof<M34f>; FieldType = typeof<float32>; Dimension = V2i(4, 3) }
+            { Type = typeof<M34d>; FieldType = typeof<float>; Dimension = V2i(4, 3) }
+            { Type = typeof<M44i>; FieldType = typeof<int32>; Dimension = V2i(4, 4) }
+            { Type = typeof<M44l>; FieldType = typeof<int64>; Dimension = V2i(4, 4) }
+            { Type = typeof<M44f>; FieldType = typeof<float32>; Dimension = V2i(4, 4) }
+            { Type = typeof<M44d>; FieldType = typeof<float>; Dimension = V2i(4, 4) }
+        ]
+
+    let IntegralTypes : Type list =
+        [
+            typeof<uint8>
+            typeof<int8>
+            typeof<int16>
+            typeof<uint16>
+            typeof<int32>
+            typeof<uint32>
+            typeof<int64>
+            typeof<uint64>
+        ]
+
+    let FractionalTypes : Type list =
+        [ typeof<float16>; typeof<float32>; typeof<float>; typeof<decimal> ]
+
+    let NumericTypes : Type list =
+        IntegralTypes @ FractionalTypes
+
+    module Patterns =
+
+        [<AutoOpen>]
+        module private Lookup =
+
+            let vectorTypes =
+                VectorTypes
+                |> List.map (fun vt -> struct (vt.Type, struct (vt.Dimension, vt.FieldType)))
+                |> Dictionary.ofListV
+
+            let colorTypes =
+                ColorTypes
+                |> List.map (fun ct -> struct (ct.Type, struct (ct.Dimension, ct.FieldType)))
+                |> Dictionary.ofListV
+
+            let matrixTypes =
+                MatrixTypes
+                |> List.map (fun mt -> struct (mt.Type, struct (mt.Dimension, mt.FieldType)))
+                |> Dictionary.ofListV
+
+            let integralTypes =
+                IntegralTypes |> HashSet.ofList
+
+            let fractionalTypes =
+                FractionalTypes |> HashSet.ofList
+
+            let numericTypes =
+                NumericTypes |> HashSet.ofList
+
+        /// Determines if the given type is a bool.
+        [<return: Struct>]
+        let inline (|Bool|_|) (t: Type) =
+            if t = typeof<bool> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a uint8.
+        [<return: Struct>]
+        let inline (|UInt8|_|) (t: Type) =
+            if t = typeof<uint8> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a int8.
+        [<return: Struct>]
+        let inline (|Int8|_|) (t: Type) =
+            if t = typeof<int8> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a int16.
+        [<return: Struct>]
+        let inline (|Int16|_|) (t: Type) =
+            if t = typeof<int16> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a uint16.
+        [<return: Struct>]
+        let inline (|UInt16|_|) (t: Type) =
+            if t = typeof<uint16> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a int32.
+        [<return: Struct>]
+        let inline (|Int32|_|) (t: Type) =
+            if t = typeof<int32> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a uint32.
+        [<return: Struct>]
+        let inline (|UInt32|_|) (t: Type) =
+            if t = typeof<uint32> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a int64.
+        [<return: Struct>]
+        let inline (|Int64|_|) (t: Type) =
+            if t = typeof<int64> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a uint64.
+        [<return: Struct>]
+        let inline (|UInt64|_|) (t: Type) =
+            if t = typeof<uint64> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a float32.
+        [<return: Struct>]
+        let inline (|Float32|_|) (t: Type) =
+            if t = typeof<float32> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a float.
+        [<return: Struct>]
+        let inline (|Float64|_|) (t: Type) =
+            if t = typeof<float> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a float16.
+        [<return: Struct>]
+        let inline (|Float16|_|) (t: Type) =
+            if t = typeof<float16> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a decimal.
+        [<return: Struct>]
+        let inline (|Decimal|_|) (t: Type) =
+            if t = typeof<decimal> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a char.
+        [<return: Struct>]
+        let inline (|Char|_|) (t: Type) =
+            if t = typeof<char> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a string.
+        [<return: Struct>]
+        let inline (|String|_|) (t: Type) =
+            if t = typeof<string> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a IntPtr.
+        [<return: Struct>]
+        let inline (|IntPtr|_|) (t : Type) =
+            if t = typeof<IntPtr> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is unit.
+        [<return: Struct>]
+        let inline (|Unit|_|) (t : Type) =
+            if t = typeof<unit> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is an enumeration.
+        [<return: Struct>]
+        let inline (|Enum|_|) (t : Type) =
+            if t.IsEnum then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is an integral type.
+        [<return: Struct>]
+        let (|Integral|_|) (t : Type) =
+            if integralTypes.Contains t then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is half, float, double, or decimal.
+        [<return: Struct>]
+        let (|Fractional|_|) (t : Type) =
+            if fractionalTypes.Contains t then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a numeric type (i.e. half, float, double, decimal, or an integral type).
+        [<return: Struct>]
+        let (|Numeric|_|) (t : Type) =
+            if numericTypes.Contains t then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a vector type.
+        [<return: Struct>]
+        let (|Vector|_|) (t: Type) =
+            if vectorTypes.ContainsKey t then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a color type.
+        [<return: Struct>]
+        let (|Color|_|) (t: Type) =
+            if colorTypes.ContainsKey t then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a matrix type.
+        [<return: Struct>]
+        let (|Matrix|_|) (t: Type) =
+            if matrixTypes.ContainsKey t then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a vector type.
+        /// Returns the dimension and the underlying type.
+        [<return: Struct>]
+        let (|VectorOf|_|) (t: Type) =
+            vectorTypes.TryFindV t
+
+        /// Determines if the given type is a color type.
+        /// Returns the dimension and the underlying type.
+        [<return: Struct>]
+        let (|ColorOf|_|) (t: Type) =
+            colorTypes.TryFindV t
+
+        /// Determines if the given type is a matrix type.
+        /// Returns the dimension (columns, rows) and the underlying type.
+        [<return: Struct>]
+        let (|MatrixOf|_|) (t: Type) =
+            matrixTypes.TryFindV t
+
+        /// Determines if the given type is a reference type.
+        /// Returns the underlying type.
+        [<return: Struct>]
+        let inline (|RefOf|_|) (t : Type) =
+            if t.IsGenericType && t.GetGenericTypeDefinition() = typedefof<int ref> then ValueSome <| t.GetGenericArguments().[0]
+            else ValueNone
+
+        /// Determines if the given type is a list type.
+        /// Returns the underlying type.
+        [<return: Struct>]
+        let inline (|ListOf|_|) (t : Type) =
+            if t.IsGenericType && t.GetGenericTypeDefinition() = typedefof<int list> then ValueSome <| t.GetGenericArguments().[0]
+            else ValueNone
+
+        /// Determines if the given type is a sequence type.
+        /// Returns the underlying type.
+        [<return: Struct>]
+        let inline (|SeqOf|_|) (t : Type) =
+            if t.IsGenericType && t.GetGenericTypeDefinition() = typedefof<int seq> then ValueSome <| t.GetGenericArguments().[0]
+            else ValueNone
\ No newline at end of file
diff --git a/src/Aardvark.Base.FSharp/Reflection/TypeMeta_template.fs b/src/Aardvark.Base.FSharp/Reflection/TypeMeta_template.fs
new file mode 100644
index 000000000..91ac38a93
--- /dev/null
+++ b/src/Aardvark.Base.FSharp/Reflection/TypeMeta_template.fs
@@ -0,0 +1,197 @@
+namespace Aardvark.Base
+
+open System
+
+/// Contains metadata associated with types and provides active patterns deconstructing vector/matrix types etc.
+module TypeMeta =
+
+    [<Struct>]
+    type VectorType =
+        {
+            Type      : Type
+            FieldType : Type
+            Dimension : int
+        }
+
+    [<Struct>]
+    type MatrixType =
+        {
+            Type      : Type
+            FieldType : Type
+            Dimension : V2i
+        }
+
+    let VectorTypes : VectorType list =
+        [
+            //# foreach (var vt in Meta.VecTypes) {
+            { Type = typeof<__vt.Name__>; FieldType = typeof<__vt.FieldType.FSharpName__>; Dimension = __vt.Len__ }
+            //# }
+        ]
+
+    let ColorTypes : VectorType list =
+        [
+            //# foreach (var ct in Meta.ColorTypes) {
+            { Type = typeof<__ct.Name__>; FieldType = typeof<__ct.FieldType.FSharpName__>; Dimension = __ct.Len__ }
+            //# }
+        ]
+
+    let MatrixTypes : MatrixType list =
+        [
+            //# foreach (var mt in Meta.MatTypes) {
+            { Type = typeof<__mt.Name__>; FieldType = typeof<__mt.FieldType.FSharpName__>; Dimension = V2i(__mt.Cols__, __mt.Rows__) }
+            //# }
+        ]
+
+    let IntegralTypes : Type list =
+        [
+            //# foreach(var t in Meta.IntegerTypes) {
+            typeof<__t.FSharpName__>
+            //# }
+        ]
+
+    let FractionalTypes : Type list =
+        [ typeof<float16>; typeof<float32>; typeof<float>; typeof<decimal> ]
+
+    let NumericTypes : Type list =
+        IntegralTypes @ FractionalTypes
+
+    module Patterns =
+
+        [<AutoOpen>]
+        module private Lookup =
+
+            let vectorTypes =
+                VectorTypes
+                |> List.map (fun vt -> struct (vt.Type, struct (vt.Dimension, vt.FieldType)))
+                |> Dictionary.ofListV
+
+            let colorTypes =
+                ColorTypes
+                |> List.map (fun ct -> struct (ct.Type, struct (ct.Dimension, ct.FieldType)))
+                |> Dictionary.ofListV
+
+            let matrixTypes =
+                MatrixTypes
+                |> List.map (fun mt -> struct (mt.Type, struct (mt.Dimension, mt.FieldType)))
+                |> Dictionary.ofListV
+
+            let integralTypes =
+                IntegralTypes |> HashSet.ofList
+
+            let fractionalTypes =
+                FractionalTypes |> HashSet.ofList
+
+            let numericTypes =
+                NumericTypes |> HashSet.ofList
+
+        //# var patternTypes =
+        //#    Meta.BuiltInTypes
+        //#    .Concat(Meta.HalfType.IntoArray())
+        //#    .Concat(Meta.DecimalType.IntoArray())
+        //#    .Concat(Meta.CharType.IntoArray())
+        //#    .Concat(Meta.StringType.IntoArray());
+        //# foreach (var t in patternTypes) {
+        //# var name = t.FSharpName;
+        //# var caps = name.StartsWith("uint") ? 2 : 1;
+        //# var patternName = name.Substring(0, caps).ToUpperInvariant() + name.Substring(caps);
+        //# if (patternName == "Float") patternName = "Float64";
+        //# var pattern = $"(|{patternName}|_|)";
+        /// Determines if the given type is a __name__.
+        [<return: Struct>]
+        let inline __pattern__ (t: Type) =
+            if t = typeof<__name__> then ValueSome ()
+            else ValueNone
+
+        //# }
+        /// Determines if the given type is a IntPtr.
+        [<return: Struct>]
+        let inline (|IntPtr|_|) (t : Type) =
+            if t = typeof<IntPtr> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is unit.
+        [<return: Struct>]
+        let inline (|Unit|_|) (t : Type) =
+            if t = typeof<unit> then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is an enumeration.
+        [<return: Struct>]
+        let inline (|Enum|_|) (t : Type) =
+            if t.IsEnum then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is an integral type.
+        [<return: Struct>]
+        let (|Integral|_|) (t : Type) =
+            if integralTypes.Contains t then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is half, float, double, or decimal.
+        [<return: Struct>]
+        let (|Fractional|_|) (t : Type) =
+            if fractionalTypes.Contains t then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a numeric type (i.e. half, float, double, decimal, or an integral type).
+        [<return: Struct>]
+        let (|Numeric|_|) (t : Type) =
+            if numericTypes.Contains t then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a vector type.
+        [<return: Struct>]
+        let (|Vector|_|) (t: Type) =
+            if vectorTypes.ContainsKey t then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a color type.
+        [<return: Struct>]
+        let (|Color|_|) (t: Type) =
+            if colorTypes.ContainsKey t then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a matrix type.
+        [<return: Struct>]
+        let (|Matrix|_|) (t: Type) =
+            if matrixTypes.ContainsKey t then ValueSome ()
+            else ValueNone
+
+        /// Determines if the given type is a vector type.
+        /// Returns the dimension and the underlying type.
+        [<return: Struct>]
+        let (|VectorOf|_|) (t: Type) =
+            vectorTypes.TryFindV t
+
+        /// Determines if the given type is a color type.
+        /// Returns the dimension and the underlying type.
+        [<return: Struct>]
+        let (|ColorOf|_|) (t: Type) =
+            colorTypes.TryFindV t
+
+        /// Determines if the given type is a matrix type.
+        /// Returns the dimension (columns, rows) and the underlying type.
+        [<return: Struct>]
+        let (|MatrixOf|_|) (t: Type) =
+            matrixTypes.TryFindV t
+
+        /// Determines if the given type is a reference type.
+        /// Returns the underlying type.
+        [<return: Struct>]
+        let inline (|RefOf|_|) (t : Type) =
+            if t.IsGenericType && t.GetGenericTypeDefinition() = typedefof<int ref> then ValueSome <| t.GetGenericArguments().[0]
+            else ValueNone
+
+        /// Determines if the given type is a list type.
+        /// Returns the underlying type.
+        [<return: Struct>]
+        let inline (|ListOf|_|) (t : Type) =
+            if t.IsGenericType && t.GetGenericTypeDefinition() = typedefof<int list> then ValueSome <| t.GetGenericArguments().[0]
+            else ValueNone
+
+        /// Determines if the given type is a sequence type.
+        /// Returns the underlying type.
+        [<return: Struct>]
+        let inline (|SeqOf|_|) (t : Type) =
+            if t.IsGenericType && t.GetGenericTypeDefinition() = typedefof<int seq> then ValueSome <| t.GetGenericArguments().[0]
+            else ValueNone
\ No newline at end of file
diff --git a/src/Aardvark.Base.FSharp/Runtime/Fragments.fs b/src/Aardvark.Base.FSharp/Runtime/Fragments.fs
index bf56d8428..c1cc7bbcb 100644
--- a/src/Aardvark.Base.FSharp/Runtime/Fragments.fs
+++ b/src/Aardvark.Base.FSharp/Runtime/Fragments.fs
@@ -82,7 +82,7 @@ module AMD64 =
         
         let getArgumentLocation (arg : int) (argType : Type) (cc : CallingConvention) =
             match argType with
-                | TypeInfo.Patterns.Fractional -> 
+                | TypeMeta.Patterns.Fractional ->
                     if arg < cc.floatRegisters.Length then RegisterArgument cc.floatRegisters.[arg]
                     else StackArgument
                 | _ -> 
diff --git a/src/Aardvark.Base/AlgoDat/Meta.cs b/src/Aardvark.Base/AlgoDat/Meta.cs
index 96d448ca6..d6ebb9e71 100644
--- a/src/Aardvark.Base/AlgoDat/Meta.cs
+++ b/src/Aardvark.Base/AlgoDat/Meta.cs
@@ -19,6 +19,9 @@ public class SimpleType
             public bool IsReal { get; set; }
             public bool IsCharOrString { get; set; }
 
+            private string m_fsharpName;
+            public string FSharpName { get => m_fsharpName ?? Name; set => m_fsharpName = value; }
+
 
             public SimpleType()
             { }
@@ -135,6 +138,7 @@ public ColorType(string name)
             Caps = "Byte",
             Char = "b",
             Read = "ReadByte",
+            FSharpName = "uint8",
             IsInteger = true,
         };
 
@@ -144,6 +148,7 @@ public ColorType(string name)
             Caps = "SByte",
             Char = "sb",
             Read = "ReadSByte",
+            FSharpName = "int8",
             IsInteger = true,
         };
 
@@ -153,6 +158,7 @@ public ColorType(string name)
             Caps = "Short",
             Char = "s",
             Read = "ReadInt16",
+            FSharpName = "int16",
             IsInteger = true,
         };
 
@@ -162,6 +168,7 @@ public ColorType(string name)
             Caps = "UShort",
             Char = "us",
             Read = "ReadUInt16",
+            FSharpName = "uint16",
             IsInteger = true,
         };
 
@@ -171,6 +178,7 @@ public ColorType(string name)
             Caps = "Int",
             Char = "i",
             Read = "ReadInt32",
+            FSharpName = "int32",
             IsInteger = true,
         };
 
@@ -180,6 +188,7 @@ public ColorType(string name)
             Caps = "UInt",
             Char = "ui",
             Read = "ReadUInt32",
+            FSharpName = "uint32",
             IsInteger = true,
         };
 
@@ -189,6 +198,7 @@ public ColorType(string name)
             Caps = "Long",
             Char = "l",
             Read = "ReadInt64",
+            FSharpName = "int64",
             IsInteger = true,
         };
 
@@ -198,6 +208,7 @@ public ColorType(string name)
             Caps = "ULong",
             Char = "ul",
             Read = "ReadUInt64",
+            FSharpName = "uint64",
             IsInteger = true,
         };
 
@@ -207,6 +218,7 @@ public ColorType(string name)
             Caps = "Half",
             Char = "h",
             Read = "ReadHalf",
+            FSharpName = "float16",
             IsReal = true,
         };
 
@@ -216,6 +228,7 @@ public ColorType(string name)
             Caps = "Float",
             Char = "f",
             Read = "ReadSingle",
+            FSharpName = "float32",
             IsReal = true,
         };
 
@@ -225,6 +238,7 @@ public ColorType(string name)
             Caps = "Double",
             Char = "d",
             Read = "ReadDouble",
+            FSharpName = "float",
             IsReal = true,
         };
 
@@ -239,6 +253,7 @@ public ColorType(string name)
         {
             Name = "Char",
             Read = "ReadChar",
+            FSharpName = "char",
             IsCharOrString = true,
         };
 
@@ -246,6 +261,7 @@ public ColorType(string name)
         {
             Name = "String",
             Read = "ReadString",
+            FSharpName = "string",
             IsCharOrString = true,
         };
 
diff --git a/src/Tests/Aardvark.Base.FSharp.Benchmarks/Aardvark.Base.FSharp.Benchmarks.fsproj b/src/Tests/Aardvark.Base.FSharp.Benchmarks/Aardvark.Base.FSharp.Benchmarks.fsproj
index b85a25551..80bcc1114 100644
--- a/src/Tests/Aardvark.Base.FSharp.Benchmarks/Aardvark.Base.FSharp.Benchmarks.fsproj
+++ b/src/Tests/Aardvark.Base.FSharp.Benchmarks/Aardvark.Base.FSharp.Benchmarks.fsproj
@@ -28,6 +28,7 @@
     <Compile Include="TensorUtilitiesBench.fs" />
     <Compile Include="TensorMathBench.fs" />
     <Compile Include="DynamicDispatchBench.fs" />
+    <Compile Include="TypePatternsBench.fs" />
     <Compile Include="Program.fs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/Tests/Aardvark.Base.FSharp.Benchmarks/TypePatternsBench.fs b/src/Tests/Aardvark.Base.FSharp.Benchmarks/TypePatternsBench.fs
new file mode 100644
index 000000000..b935c5fe5
--- /dev/null
+++ b/src/Tests/Aardvark.Base.FSharp.Benchmarks/TypePatternsBench.fs
@@ -0,0 +1,99 @@
+namespace Aardvark.Base.FSharp.Benchmarks
+
+#nowarn "44"
+
+open System
+open Aardvark.Base
+open Aardvark.Base.TypeInfo
+open BenchmarkDotNet.Attributes
+
+module PatternsImpl =
+
+    module PatternsNaive =
+        let inline private typeInfo t = { simpleType = t } :> ITypeInfo
+
+        [<return: Struct>]
+        let inline (|Matrix|_|) (t : Type) =
+            if Set.contains (typeInfo t) MatrixTypes then
+                ValueSome ()
+            else
+                ValueNone
+
+        [<return: Struct>]
+        let inline (|MatrixOf|_|) (t : Type) =
+            MatrixTypes
+            |> Seq.tryFindV (fun vi -> vi.Type.Name = t.Name)
+            |> ValueOption.map (fun t ->
+                let mt = unbox<MatrixType> t
+                mt.dimension, mt.baseType.Type
+            )
+
+        [<return: Struct>]
+        let inline (|List|_|) (t : Type) =
+            if t.IsGenericType && t.GetGenericTypeDefinition() = TList.simpleType then
+                ValueSome <| t.GetGenericArguments().[0]
+            else
+                ValueNone
+
+[<MemoryDiagnoser>]
+type ``TypePatterns Matrix``() =
+
+    member inline x.IsMatrixNaive (t: Type) =
+        match t with
+        | PatternsImpl.PatternsNaive.Matrix -> true
+        | _ -> false
+
+    member inline x.IsMatrixOptimized (t: Type) =
+        match t with
+        | TypeMeta.Patterns.Matrix -> true
+        | _ -> false
+
+    [<Benchmark(Description = "Naive", Baseline = true)>]
+    member x.Naive() =
+        x.IsMatrixNaive typeof<M44d> && x.IsMatrixNaive typeof<unit>
+
+    [<Benchmark(Description = "Optimized")>]
+    member x.Optimized() =
+        x.IsMatrixOptimized typeof<M44d> && x.IsMatrixOptimized typeof<unit>
+
+[<MemoryDiagnoser>]
+type ``TypePatterns MatrixOf``() =
+
+    member inline x.IsMatrixNaive (t: Type) =
+        match t with
+        | PatternsImpl.PatternsNaive.MatrixOf(dim, baseType) -> true
+        | _ -> false
+
+    member inline x.IsMatrixOptimized (t: Type) =
+        match t with
+        | TypeMeta.Patterns.MatrixOf(dim, baseType) -> true
+        | _ -> false
+
+    [<Benchmark(Description = "Naive", Baseline = true)>]
+    member x.Naive() =
+        x.IsMatrixNaive typeof<M44d> && x.IsMatrixNaive typeof<unit>
+
+    [<Benchmark(Description = "Optimized")>]
+    member x.Optimized() =
+        x.IsMatrixOptimized typeof<M44d> && x.IsMatrixOptimized typeof<unit>
+
+[<MemoryDiagnoser>]
+type ``TypePatterns List``() =
+
+    member inline x.IsListNaive (t: Type) =
+        match t with
+        | PatternsImpl.PatternsNaive.List(baseType) -> true
+        | _ -> false
+
+    member inline x.IsListOptimized (t: Type) =
+        match t with
+        | TypeMeta.Patterns.ListOf(baseType) -> true
+        | _ -> false
+
+    [<Benchmark(Description = "Naive", Baseline = true)>]
+    member x.Naive() =
+        x.IsListNaive typeof<list<M44d>> && x.IsListNaive typeof<unit>
+
+    [<Benchmark(Description = "Optimized")>]
+    member x.Optimized() =
+        x.IsListOptimized typeof<list<M44d>> && x.IsListOptimized typeof<unit>
\ No newline at end of file
diff --git a/src/Tests/Aardvark.Base.FSharp.Tests/Aardvark.Base.FSharp.Tests.fsproj b/src/Tests/Aardvark.Base.FSharp.Tests/Aardvark.Base.FSharp.Tests.fsproj
index 854a7c3fd..4dcbc73fc 100644
--- a/src/Tests/Aardvark.Base.FSharp.Tests/Aardvark.Base.FSharp.Tests.fsproj
+++ b/src/Tests/Aardvark.Base.FSharp.Tests/Aardvark.Base.FSharp.Tests.fsproj
@@ -34,6 +34,7 @@
     <Compile Include="NativeMemory.fs" />
     <Compile Include="ControlTests.fs" />
     <Compile Include="SizeOfTests.fs" />
+    <Compile Include="TypePatternsTests.fs" />
     <Compile Include="Program.fs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/Tests/Aardvark.Base.FSharp.Tests/TypePatternsTests.fs b/src/Tests/Aardvark.Base.FSharp.Tests/TypePatternsTests.fs
new file mode 100644
index 000000000..ff1bdd5c6
--- /dev/null
+++ b/src/Tests/Aardvark.Base.FSharp.Tests/TypePatternsTests.fs
@@ -0,0 +1,50 @@
+namespace Aardvark.Base.FSharp.Tests
+
+open System
+open Aardvark.Base
+open Aardvark.Base.TypeMeta
+
+open FsUnit
+open NUnit.Framework
+
+module ``TypePatterns Tests`` =
+
+    [<Test>]
+    let ``[TypePatterns] Matrix``() =
+        let test43 (t: Type) =
+            match t with
+            | MatrixOf (s, Integral) -> s |> should equal (V2i(4, 3))
+            | _ -> failwith $"failed pattern {t}"
+
+        test43 typeof<M34i>
+        test43 typeof<M34l>
+
+    [<Test>]
+    let ``[TypePatterns] List``() =
+        let test (t: Type) =
+            match t with
+            | ListOf Fractional -> ()
+            | _ -> failwithf $"failed pattern {t}"
+
+        test typeof<list<float16>>
+        test typeof<list<float32>>
+
+    [<Test>]
+    let ``[TypePatterns] Seq``() =
+        let test (t: Type) =
+            match t with
+            | SeqOf Numeric -> ()
+            | _ -> failwithf $"failed pattern {t}"
+
+        test typeof<seq<decimal>>
+        test typeof<seq<int8>>
+
+    [<Test>]
+    let ``[TypePatterns] Ref``() =
+        let test (t: Type) =
+            match t with
+            | RefOf Vector -> ()
+            | _ -> failwithf $"failed pattern {t}"
+
+        test typeof<ref<V3ui>>
+        test typeof<ref<V2d>>
\ No newline at end of file