Allow not setting optional objects and arrays whilst encoding.

src/Encoder/EncoderDetector.php

@@ -51,6 +51,10 @@ public function __invoke(Context $context): XmlEncoder
             $encoder = new RepeatingElementEncoder($encoder);
         }
 
+        if (!$encoder instanceof Feature\OptionalAware && $meta->isNullable()->unwrapOr(false)) {
+            $encoder = new OptionalElementEncoder($encoder);
+        }
+
         $encoder = new ErrorHandlingEncoder($encoder);
 
         return $this->cache[$type] = $encoder;

src/Encoder/Feature/ListAware.php

@@ -3,6 +3,9 @@
 
 namespace Soap\Encoding\Encoder\Feature;
 
+/**
+ * Tells the encoder knows how to teal with list inputs.
+ */
 interface ListAware extends DisregardXsiInformation
 {
 }

src/Encoder/Feature/OptionalAware.php

@@ -0,0 +1,11 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Encoder\Feature;
+
+/**
+ * Tells the encoder knows about optional (nullable) values.
+ */
+interface OptionalAware extends DisregardXsiInformation
+{
+}

src/Encoder/OptionalElementEncoder.php

@@ -13,7 +13,7 @@
  * @template T of mixed
  * @implements XmlEncoder<T, string>
  */
-final class OptionalElementEncoder implements XmlEncoder
+final class OptionalElementEncoder implements Feature\OptionalAware, XmlEncoder
 {
     /**
      * @param XmlEncoder<T, string> $elementEncoder

src/Encoder/RepeatingElementEncoder.php

@@ -12,7 +12,7 @@
 
 /**
  * @template T
- * @implements XmlEncoder<iterable<array-key, T>, string>
+ * @implements XmlEncoder<iterable<array-key, T>|null, string>
  */
 final class RepeatingElementEncoder implements Feature\ListAware, XmlEncoder
 {
@@ -25,7 +25,7 @@ public function __construct(
     }
 
     /**
-     * @return Iso<iterable<array-key, T>, string>
+     * @return Iso<iterable<array-key, T>|null, string>
      */
     public function iso(Context $context): Iso
     {
@@ -39,12 +39,12 @@ public function iso(Context $context): Iso
 
         return new Iso(
             /**
-             * @param iterable<array-key, T> $raw
+             * @param iterable<array-key, T>|null $raw
              */
-            static function (iterable $raw) use ($innerIso): string {
+            static function (iterable|null $raw) use ($innerIso): string {
                 return join(
                     map(
-                        $raw,
+                        $raw ?? [],
                         /**
                          * @param T $item
                          */

src/Encoder/SimpleType/EncoderDetector.php

@@ -39,9 +39,11 @@ public function __invoke(Context $context): XmlEncoder
         }
 
         if ($meta->isElement()->unwrapOr(false)) {
-            $encoder = new OptionalElementEncoder(
-                new ElementEncoder($encoder)
-            );
+            $encoder = new ElementEncoder($encoder);
+
+            if ($meta->isNullable()->unwrapOr(false)) {
+                $encoder = new OptionalElementEncoder($encoder);
+            }
         }
 
         return $encoder;

tests/PhpCompatibility/Implied/ImpliedSchema004Test.php

@@ -0,0 +1,64 @@
+<?php
+declare(strict_types=1);
+
+namespace Soap\Encoding\Test\PhpCompatibility\Implied;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use Soap\Encoding\Decoder;
+use Soap\Encoding\Driver;
+use Soap\Encoding\Encoder;
+use Soap\Encoding\Test\PhpCompatibility\AbstractCompatibilityTests;
+
+#[CoversClass(Driver::class)]
+#[CoversClass(Encoder::class)]
+#[CoversClass(Decoder::class)]
+final class ImpliedSchema004Test extends AbstractCompatibilityTests
+{
+    protected string $schema = <<<EOXML
+    <element name="testType">
+        <complexType>
+            <sequence>
+                <element name="OptionalList" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>
+                <element name="OptionalSimpleElement" type="xsd:string" minOccurs="0" maxOccurs="1"/>
+                <element name="OptionalObject" minOccurs="0">
+                    <complexType>
+                        <sequence>
+                            <element name="item" type="xsd:string" minOccurs="0" maxOccurs="unbounded"/>
+                        </sequence>
+                    </complexType>
+                </element>
+            </sequence>
+        </complexType>
+    </element>
+    EOXML;
+    protected string $type = 'type="tns:testType"';
+
+    protected function calculateParam(): mixed
+    {
+        return (object)[];
+    }
+
+    protected function expectDecoded(): mixed
+    {
+        return (object)[
+            'OptionalList' => [],
+            'OptionalSimpleElement' => null,
+            'OptionalObject' => null,
+        ];
+    }
+
+    protected function expectXml(): string
+    {
+        return <<<XML
+         <SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tns="http://test-uri/"
+            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+            xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/">
+            <SOAP-ENV:Body SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
+                <tns:test>
+                    <testParam xsi:type="tns:testType" />
+                </tns:test>
+            </SOAP-ENV:Body>
+        </SOAP-ENV:Envelope>
+        XML;
+    }
+}

tests/Unit/Encoder/RepeatingElementEncoderTest.php

@@ -82,4 +82,19 @@ public function test_it_can_decode_from_xml_item_list(): void
 
         static::assertEquals(['world'], $actual);
     }
+
+    public function test_it_can_encode_from_null(): void
+    {
+        $encoder = new RepeatingElementEncoder(new ElementEncoder(new StringTypeEncoder()));
+        $context = self::createContext(
+            XsdType::guess('string')
+                ->withXmlTargetNodeName('hello')
+                ->withMeta(static fn (TypeMeta $meta): TypeMeta => $meta->withIsQualified(true))
+        );
+
+        $iso = $encoder->iso($context);
+        $actual = $iso->to(null);
+
+        static::assertSame('', $actual);
+    }
 }