Attributes

[mattesmohr]

There exist some attributes, wich are exclusive for a specific element. For example:

/// The protocol provides the element with the `wrap=""` attribute.
///
/// e.g. `<textarea>`
///
public protocol WrapAttribute {
    
    func wrap(_ type: WrapType) -> Self
}

So I was wondering if we should include the attribute as a parameter in the initialiser instead of a possible function. I have seen, you have done it in the past for one element. I would write it for each element, wich has such an exclusive attribute.

SwiftUI does it aswell. For example:

VStack(alignment: .leading) { ... }

So I tried to find out, when SwiftUI is doing it, and when it doesn't. The only answer I came up with, is that SwiftUI prefers the parameter instead of the punctuation, when the element depends on the attribute. Like the VStack needs to know the alignment to understand how the content should be displayed. For example:

<input type="button">

The input itself is nothing without the type definition. Its like a required attribute. But since the type-Attribute is used by many elements. For example:

/// The protocol provides the element with the type attribute.
///
/// e.g. `<a>`, `<button>`, `<embed>`, `<input>`, `<link>`, `<ol>`,
/// `<object>`, `<script>`, `<source>`, `<style>`
///
public protocol TypeAttribute {

    func type(_ value: TemplateValue<String>) -> Self
}

From a coder perspective its totally fine two write a protocol here. It means less code duplication, right?

So I think we have three options here:

1. Exclusive and required attributes as parameter.

Pro: Less code (at least I think). Less errors, since the initialisers gives right away, that some parameters are needed. Less attribute-stacking.

Element(para:) { 
… 
}
.func()

Instead:

Element() { 
… 
}
.func()
.func()
.func()

Contra: More effort to implement.

2. All Attributes are the same.

Pro: Everything is the same. There is no exception. Attributes means Punctuation.
Contra: Maybe more errors.

3. Both ways.

Pro: The user has a choice.
Contra: More Effort. Maybe some code confusion.

[MatsMoll]

Here I think it is best to choose one method. And here I like the first path the best.

Adding required attributes in the init, and then making it possible to add optional attributes afterwards. Even tho it is a bit more effort, I find it cleaner and harder to make user mistakes.

[mattesmohr]

Cool. Yes I think the effort is worth the change. Keep you posted.