Sure, in which case the solution in Rust is just:
let x = 123;
let y = std::slice::from_ref(&x);
which might look something like the following in Swift:
let x = 123
let y = Span(Ref(x))
(Although, blindly accepting a Ref wouldn't work because of the bizarre representation it has...)
The empty span initializer does feel weird to me over a value as others have already noted.
I don't hate this direction. I would probably spell it something like Span(ofOne:).
Agree strongly with Tony that having to go through Ref would not be ideal from a discoverability perspective.
Or: Span(element:)?
element waves vaguely in the direction of Array, connoting an array of one element, from which taking a span isn't a new concept.
I don't particularly like element: as the label, since we do have or will need to use the plural elements: in similar contexts as well. However, I do like ofOne:.
As a companion to Span(ofOne:) and MutableSpan(ofOne:), I do think that RawSpan(ofOne: some ConvertibleToBytes) and MutableRawSpan(ofOne: some FullyInhabited) also work.
Noted!
I'm unclear on what contexts you mean. Are you talking about a hypothetical Span(elements:), or something in another type (or a series of types)?
In my original suggestion, I was reacting to using "one" or "single" in the label. Since there is only one argument, and the argument is a single non-collection value, it seems redundant to put the number of arguments into the function signature. It's "obviously" one single value, and redundantly explaining that perhaps doesn't help someone meeting the signature for the first time.
Instead, it seems more helpful to use the label to emphasize what the argument is. Another suggestion in the same vein would be Span(value:), but I can imagine many other directions to go that don't get hung up on a redundant "one".
In this case, I don’t feel the “one” is redundant. Yes, it’s obvious from the call that there's only a single argument, but the fact that we’re making a span over exactly that one value, as opposed to somehow deriving a more general span from the value (as with Array.span), is a significant difference for the reader that’s worth underlining.
It would be a decent label to use when initializing containers in some situations, such as UniqueArray.
The argument is a single anything; the type would effectively be some Any. It's probably useful to specify that it's one thing, to minimize confusion over containers passed as the argument.
Seconding this with a concrete example. Swift Build had a place where it did Set("\\/"), and I was terribly confused for a few minutes how this code had ever worked. Being clear about whether a single argument is being treated as itself or as its contents is helpful.
Span(ofOne: jawn) also makes sense because this is essentially shorthand for CollectionOfOne(jawn).span.