diff --git a/tests/tests.rs b/tests/tests.rs
index 8298604e..0a84be96 100644
--- a/tests/tests.rs
+++ b/tests/tests.rs
@@ -66,6 +66,49 @@ fn test_generics() {
     assert!(Foo::builder().x(1).y(2).build() == Foo { x: 1, y: 2 });
 }
 
+#[test]
+fn test_2d_const_generics() {
+    #[derive(PartialEq, TypedBuilder)]
+    struct Foo<const NUM_COLS: usize, const NUM_ROWS: usize> {
+        data: [[u32; NUM_ROWS]; NUM_COLS],
+    }
+    assert!(Foo::builder().data([[]]).build() == Foo { data: [[]] });
+}
+
+#[test]
+fn test_multiple_const_generics() {
+    #[derive(PartialEq, TypedBuilder)]
+    struct Foo<const A: usize, const B: usize, const C: usize> {
+        data: [u32; A],
+        data2: [u32; B],
+        data3: [u32; C],
+    }
+    assert!(
+        Foo::builder().data([1]).data2([2, 3]).data3([]).build()
+            == Foo {
+                data: [1],
+                data2: [2, 3],
+                data3: []
+            }
+    );
+}
+
+#[test]
+fn test_const_generics_with_other_generics() {
+    #[derive(PartialEq, TypedBuilder)]
+    struct Foo<const A: usize, B> {
+        data: [B; A],
+        data2: [B; 3],
+    }
+    assert!(
+        Foo::builder().data([3]).data2([0, 1, 2]).build()
+            == Foo {
+                data: [3],
+                data2: [0, 1, 2]
+            }
+    );
+}
+
 #[test]
 fn test_into() {
     #[derive(PartialEq, TypedBuilder)]
diff --git a/typed-builder-macro/src/struct_info.rs b/typed-builder-macro/src/struct_info.rs
index 87c6ebe2..01860833 100644
--- a/typed-builder-macro/src/struct_info.rs
+++ b/typed-builder-macro/src/struct_info.rs
@@ -67,16 +67,16 @@ impl<'a> StructInfo<'a> {
         let generics_with_empty = modify_types_generics_hack(&ty_generics, |args| {
             args.push(syn::GenericArgument::Type(empties_tuple.clone().into()));
         });
-        let phantom_generics = self.generics.params.iter().map(|param| match param {
+        let phantom_generics = self.generics.params.iter().filter_map(|param| match param {
             syn::GenericParam::Lifetime(lifetime) => {
                 let lifetime = &lifetime.lifetime;
-                quote!(&#lifetime ())
+                Some(quote!(&#lifetime ()))
             }
             syn::GenericParam::Type(ty) => {
                 let ty = &ty.ident;
-                ty.to_token_stream()
+                Some(ty.to_token_stream())
             }
-            syn::GenericParam::Const(_cnst) => quote!(),
+            syn::GenericParam::Const(_cnst) => None,
         });
 
         let builder_method_name = self.builder_attr.builder_method.get_name().unwrap_or_else(|| quote!(builder));