optimize: better inflation logic

Author: lsafer-meemer

mmrpc-definition/src/commonMain/kotlin/compact/CompactArrayDefinition.kt

@@ -27,23 +27,21 @@ fun ArrayDefinition.toCompact(): CompactArrayDefinition {
     )
 }
 
-fun CompactArrayDefinition.inflate(
+fun CompactArrayDefinition.inflateOrNull(
     onLookup: (CanonicalName) -> ElementDefinition?,
-): () -> ArrayDefinition? {
-    return it@{
-        ArrayDefinition(
-            canonicalName = this.canonical_name,
-            description = this.description,
-            metadata = this.metadata.map {
-                it.inflate(onLookup)() ?: return@it null
-            },
-            type = this.type_ref.let {
-                val item = onLookup(it) ?: return@it null
-                require(item is TypeDefinition) {
-                    "<array>.type_ref must point to a TypeDefinition"
-                }
-                item
+): ArrayDefinition? {
+    return ArrayDefinition(
+        canonicalName = this.canonical_name,
+        description = this.description,
+        metadata = this.metadata.map {
+            it.inflateOrNull(onLookup)() ?: return null
+        },
+        type = this.type_ref.let {
+            val item = onLookup(it) ?: return null
+            require(item is TypeDefinition) {
+                "<array>.type_ref must point to a TypeDefinition"
             }
-        )
-    }
+            item
+        }
+    )
 }

mmrpc-definition/src/commonMain/kotlin/compact/CompactConstDefinition.kt

@@ -26,24 +26,22 @@ fun ConstDefinition.toCompact(): CompactConstDefinition {
     )
 }
 
-fun CompactConstDefinition.inflate(
+fun CompactConstDefinition.inflateOrNull(
     onLookup: (CanonicalName) -> ElementDefinition?,
-): () -> ConstDefinition? {
-    return it@{
-        ConstDefinition(
-            canonicalName = this.canonical_name,
-            description = this.description,
-            metadata = this.metadata.map {
-                it.inflate(onLookup)() ?: return@it null
-            },
-            type = this.type_ref.let {
-                val item = onLookup(it) ?: return@it null
-                require(item is TypeDefinition) {
-                    "<const>.type_ref must point to a TypeDefinition"
-                }
-                item
-            },
-            value = this.value,
-        )
-    }
+): ConstDefinition? {
+    return ConstDefinition(
+        canonicalName = this.canonical_name,
+        description = this.description,
+        metadata = this.metadata.map {
+            it.inflateOrNull(onLookup)() ?: return null
+        },
+        type = this.type_ref.let {
+            val item = onLookup(it) ?: return null
+            require(item is TypeDefinition) {
+                "<const>.type_ref must point to a TypeDefinition"
+            }
+            item
+        },
+        value = this.value,
+    )
 }

mmrpc-definition/src/commonMain/kotlin/compact/CompactElementDefinition.kt

@@ -34,23 +34,23 @@ fun ElementDefinition.toCompact(): CompactElementDefinition {
     }
 }
 
-fun CompactElementDefinition.inflate(
+fun CompactElementDefinition.inflateOrNull(
     onLookup: (CanonicalName) -> ElementDefinition?,
-): () -> ElementDefinition? {
+): ElementDefinition? {
     return when (this) {
-        is CompactArrayDefinition -> inflate(onLookup)
-        is CompactConstDefinition -> inflate(onLookup)
-        is CompactEnumDefinition -> inflate(onLookup)
-        is CompactFaultDefinition -> inflate(onLookup)
-        is CompactFieldDefinition -> inflate(onLookup)
-        is CompactInterDefinition -> inflate(onLookup)
-        is CompactMetadataDefinition -> inflate(onLookup)
-        is CompactOptionalDefinition -> inflate(onLookup)
-        is CompactProtocolDefinition -> inflate(onLookup)
-        is CompactRoutineDefinition -> inflate(onLookup)
-        is CompactScalarDefinition -> inflate(onLookup)
-        is CompactStructDefinition -> inflate(onLookup)
-        is CompactTupleDefinition -> inflate(onLookup)
-        is CompactUnionDefinition -> inflate(onLookup)
+        is CompactArrayDefinition -> inflateOrNull(onLookup)
+        is CompactConstDefinition -> inflateOrNull(onLookup)
+        is CompactEnumDefinition -> inflateOrNull(onLookup)
+        is CompactFaultDefinition -> inflateOrNull(onLookup)
+        is CompactFieldDefinition -> inflateOrNull(onLookup)
+        is CompactInterDefinition -> inflateOrNull(onLookup)
+        is CompactMetadataDefinition -> inflateOrNull(onLookup)
+        is CompactOptionalDefinition -> inflateOrNull(onLookup)
+        is CompactProtocolDefinition -> inflateOrNull(onLookup)
+        is CompactRoutineDefinition -> inflateOrNull(onLookup)
+        is CompactScalarDefinition -> inflateOrNull(onLookup)
+        is CompactStructDefinition -> inflateOrNull(onLookup)
+        is CompactTupleDefinition -> inflateOrNull(onLookup)
+        is CompactUnionDefinition -> inflateOrNull(onLookup)
     }
 }

mmrpc-definition/src/commonMain/kotlin/compact/CompactEnumDefinition.kt

@@ -26,30 +26,28 @@ fun EnumDefinition.toCompact(): CompactEnumDefinition {
     )
 }
 
-fun CompactEnumDefinition.inflate(
+fun CompactEnumDefinition.inflateOrNull(
     onLookup: (CanonicalName) -> ElementDefinition?,
-): () -> EnumDefinition? {
-    return it@{
-        EnumDefinition(
-            canonicalName = this.canonical_name,
-            description = this.description,
-            metadata = this.metadata.map {
-                it.inflate(onLookup)() ?: return@it null
-            },
-            type = this.type_ref.let {
-                val item = onLookup(it) ?: return@it null
-                require(item is TypeDefinition) {
-                    "<enum>.type_ref must point to a TypeDefinition"
-                }
-                item
-            },
-            entries = this.entries_ref.map {
-                val item = onLookup(it) ?: return@it null
-                require(item is ConstDefinition) {
-                    "<enum>.entries_ref must point to a ConstDefinition"
-                }
-                item
-            },
-        )
-    }
+): EnumDefinition? {
+    return EnumDefinition(
+        canonicalName = this.canonical_name,
+        description = this.description,
+        metadata = this.metadata.map {
+            it.inflateOrNull(onLookup)() ?: return null
+        },
+        type = this.type_ref.let {
+            val item = onLookup(it) ?: return null
+            require(item is TypeDefinition) {
+                "<enum>.type_ref must point to a TypeDefinition"
+            }
+            item
+        },
+        entries = this.entries_ref.map {
+            val item = onLookup(it) ?: return null
+            require(item is ConstDefinition) {
+                "<enum>.entries_ref must point to a ConstDefinition"
+            }
+            item
+        },
+    )
 }

mmrpc-definition/src/commonMain/kotlin/compact/CompactFaultDefinition.kt

@@ -22,16 +22,14 @@ fun FaultDefinition.toCompact(): CompactFaultDefinition {
     )
 }
 
-fun CompactFaultDefinition.inflate(
+fun CompactFaultDefinition.inflateOrNull(
     onLookup: (CanonicalName) -> ElementDefinition?,
-): () -> FaultDefinition? {
-    return it@{
-        FaultDefinition(
-            canonicalName = this.canonical_name,
-            description = this.description,
-            metadata = this.metadata.map {
-                it.inflate(onLookup)() ?: return@it null
-            },
-        )
-    }
+): FaultDefinition? {
+    return FaultDefinition(
+        canonicalName = this.canonical_name,
+        description = this.description,
+        metadata = this.metadata.map {
+            it.inflateOrNull(onLookup)() ?: return null
+        },
+    )
 }

mmrpc-definition/src/commonMain/kotlin/compact/CompactFieldDefinition.kt

@@ -26,24 +26,22 @@ fun FieldDefinition.toCompact(): CompactFieldDefinition {
     )
 }
 
-fun CompactFieldDefinition.inflate(
+fun CompactFieldDefinition.inflateOrNull(
     onLookup: (CanonicalName) -> ElementDefinition?,
-): () -> FieldDefinition? {
-    return it@{
-        FieldDefinition(
-            canonicalName = this.canonical_name,
-            description = this.description,
-            metadata = this.metadata.map {
-                it.inflate(onLookup)() ?: return@it null
-            },
-            type = this.type_ref.let {
-                val item = onLookup(it) ?: return@it null
-                require(item is TypeDefinition) {
-                    "<field>.type_ref must point to a TypeDefinition"
-                }
-                item
-            },
-            default = this.default
-        )
-    }
+): FieldDefinition? {
+    return FieldDefinition(
+        canonicalName = this.canonical_name,
+        description = this.description,
+        metadata = this.metadata.map {
+            it.inflateOrNull(onLookup)() ?: return null
+        },
+        type = this.type_ref.let {
+            val item = onLookup(it) ?: return null
+            require(item is TypeDefinition) {
+                "<field>.type_ref must point to a TypeDefinition"
+            }
+            item
+        },
+        default = this.default
+    )
 }

mmrpc-definition/src/commonMain/kotlin/compact/CompactFieldDefinitionUsage.kt

@@ -17,7 +17,7 @@ fun FieldDefinitionUsage.toCompact(): CompactFieldDefinitionUsage {
     )
 }
 
-fun CompactFieldDefinitionUsage.inflate(
+fun CompactFieldDefinitionUsage.inflateOrNull(
     onLookup: (CanonicalName) -> ElementDefinition?,
 ): () -> FieldDefinitionUsage? {
     return it@{

mmrpc-definition/src/commonMain/kotlin/compact/CompactInterDefinition.kt

@@ -27,23 +27,21 @@ fun InterDefinition.toCompact(): CompactInterDefinition {
     )
 }
 
-fun CompactInterDefinition.inflate(
+fun CompactInterDefinition.inflateOrNull(
     onLookup: (CanonicalName) -> ElementDefinition?,
-): () -> InterDefinition? {
-    return it@{
-        InterDefinition(
-            canonicalName = this.canonical_name,
-            description = this.description,
-            metadata = this.metadata.map {
-                it.inflate(onLookup)() ?: return@it null
-            },
-            types = this.types_ref.map {
-                val item = onLookup(it) ?: return@it null
-                require(item is StructDefinition) {
-                    "<inter>.types_ref must point to a StructDefinition"
-                }
-                item
-            },
-        )
-    }
+): InterDefinition? {
+    return InterDefinition(
+        canonicalName = this.canonical_name,
+        description = this.description,
+        metadata = this.metadata.map {
+            it.inflateOrNull(onLookup)() ?: return null
+        },
+        types = this.types_ref.map {
+            val item = onLookup(it) ?: return null
+            require(item is StructDefinition) {
+                "<inter>.types_ref must point to a StructDefinition"
+            }
+            item
+        },
+    )
 }

mmrpc-definition/src/commonMain/kotlin/compact/CompactMetadataDefinition.kt

@@ -27,23 +27,21 @@ fun MetadataDefinition.toCompact(): CompactMetadataDefinition {
     )
 }
 
-fun CompactMetadataDefinition.inflate(
+fun CompactMetadataDefinition.inflateOrNull(
     onLookup: (CanonicalName) -> ElementDefinition?,
-): () -> MetadataDefinition? {
-    return it@{
-        MetadataDefinition(
-            canonicalName = this.canonical_name,
-            description = this.description,
-            metadata = this.metadata.map {
-                it.inflate(onLookup)() ?: return@it null
-            },
-            fields = this.fields_ref.map {
-                val item = onLookup(it) ?: return@it null
-                require(item is FieldDefinition) {
-                    "<metadata>.fields_ref must point to a FieldDefinition"
-                }
-                item
-            },
-        )
-    }
+): MetadataDefinition? {
+    return MetadataDefinition(
+        canonicalName = this.canonical_name,
+        description = this.description,
+        metadata = this.metadata.map {
+            it.inflateOrNull(onLookup)() ?: return null
+        },
+        fields = this.fields_ref.map {
+            val item = onLookup(it) ?: return null
+            require(item is FieldDefinition) {
+                "<metadata>.fields_ref must point to a FieldDefinition"
+            }
+            item
+        },
+    )
 }

mmrpc-definition/src/commonMain/kotlin/compact/CompactMetadataDefinitionUsage.kt

@@ -20,7 +20,7 @@ fun MetadataDefinitionUsage.toCompact(): CompactMetadataDefinitionUsage {
     )
 }
 
-fun CompactMetadataDefinitionUsage.inflate(
+fun CompactMetadataDefinitionUsage.inflateOrNull(
     onLookup: (CanonicalName) -> ElementDefinition?,
 ): () -> MetadataDefinitionUsage? {
     return it@{
@@ -33,7 +33,7 @@ fun CompactMetadataDefinitionUsage.inflate(
                 item
             },
             fields = this.fields.map {
-                it.inflate(onLookup)() ?: return@it null
+                it.inflateOrNull(onLookup)() ?: return@it null
             }
         )
     }