implement String(::Base.Generator)

[StefanKarpinski]

I was hoping that this would work:

String(Iterators.map(c->c+1, "Hello, world"))

Instead it's a method error. We should allow the String constructor to take a generator argument.

[ararslan]

Perhaps a method that consumes general iterators would be worthwhile, e.g.

🍝(x, ::Union{HasLength,HasShape}) = String(copyto!(StringMemory(length(x)), x))
🍝(x, ::IsInfinite) = throw(MethodError(String, (x,)))
function 🍝(x, ::SizeUnknown)
    io = IOBuffer()
    for c in x
        print(io, convert(AbstractChar, c))
    end
    return String(take!(io))
end

String(itr) = 🍝(itr, IteratorSize(itr))

That would allow supporting things like String(Iterators.take("Hello, world", 5)) as well.

[KlausC]

Attention: length is not correct in case of multi-byte characters.

[KlausC]

Maybe Base.String(itr) = String(collect(itr)) would be sufficient (plus tests for all cases implied above)
EDIT: Not true, additionally must avoid stack overflow for e.g. String(19).

String(itr) = 🍝(itr, IteratorSize(itr))
🍝(x, ::IsInfinite) = throw(MethodError(String, (x,)))
🍝(x, ::IteratorSize) = String(collect(itr)::AbstractVector{<:AbstractChar})

[ararslan]

Attention: length is not correct in case of multi-byte characters.

The length call in my suggested implementation is the length of the iterator with known length, not the length of a string. It's just used for allocating the memory required, and is actually identical to the implementation of String(::Memory) (IIRC).

[KlausC]

@ararslan you may want to look at the following output to see what I mean:

julia> String( c for c in "ÄÖao")
"\xc4\xd6ao"

[ararslan]

Ahhh yeah, thanks for the example, I see now. IteratorSize is probably not so useful a query then since HasLength only tells you that length can be assumed to be implemented. Something like

String(itr) = String([convert(AbstractChar, c) for c in itr])

should ensure you don't get a stack overflow on String(19), though the error you do get is rather opaque (MethodError on String(::Array{Char,0})).

[JimCircadian]

String(itr::Generator) = String(collect(itr)) seems to work as of 1.11.5.

@KlausC if I have the above set:

 [14] String(itr::Generator)
     @ Main REPL[5]:1

Then String(19) does not produce the overflow error.

julia> String(19)
ERROR: MethodError: no method matching String(::Int64)

It also doesn't if I add the previous 🍝 implementation from @ararslan (I get "\x13"). Given the original requirement is only to handle Generator based arguments, I feel I'm missing something. Keen to add tests and help out with this one though, so any guidance about best pathway to implementation is welcome. :)

My feeling is that we can add the single line implementation without trouble, as per title. Perhaps some tests are due to ensure that behaviour is consistent?

julia> String( c for c in "ÄÖao")
"ÄÖao"

Also works after @ararslan original implementation, so keen to see what peoples thoughts are. Thanks!