Trying to write octets to a flexi-stream fails.

[informatimago]

Trying to write octets to a flexi-stream fails.

[avodonosov]

The implementation seems to partially support binary output.
For example here:

flexi-streams/output.lisp

Line 147 in 74a1027

(when (and (vectorp sequence)

It seems, if the sequence you try to write was an array with integer element type, the output would work.

Also the docstring of that function:

An optimized version which uses a buffer underneath. The function
can accepts characters as well as octets and it decides what to do
based on the element type of the sequence (if possible) or on the
individual elements, i.e. you can mix characters and octets in
SEQUENCE if you want. Whether that really works might also depend on
your Lisp, some of the implementations are more picky than others."

Speaking of mixing the chars and octets in the sequence, the code seems to only support it for lists:

flexi-streams/encode.lisp

Line 129 in 74a1027

(list (iterate (write-object (nth index sequence))))))

For other input sequences, the code applies to every element a @body of code supplied as a parameter. See two lines above.

The body is expected to get the current element using char-getter symbol macro. And the actual bodies unconditionally pass the element to (char-code ):

flexi-streams/encode.lisp

Line 187 in 74a1027

(let ((octet (char-code char-getter)))

[informatimago]

Ok. Thank you for the answer.
Inded, when passing a (vector octet) it works, (vector T) are expected to contain only characters.

I find it regretable that libraries impose such restrictions, given that CL itself doesn't.

(with-open-file (out "/tmp/binary.out" :direction :output :element-type '(unsigned-byte 8) :if-does-not-exist :create :if-exists :supersede)
  (write-sequence #(65 66 67 68) out)
  (let ((buffer (make-array 4 :element-type '(or null string integer)
                              :initial-contents '(69 70 71 72))))
    (write-sequence buffer out)))
;; --> #(69 70 71 72)

(with-open-file (input "/tmp/binary.out" :element-type 'character)
  (read-line input))
;; --> "ABCDEFGH"
;;     t

so you may want to keep the issue to allow vectors of any type of element, as long as the contents is acceptable, or reject it (and close it).

For now I have a workaround, that makes it more costly to use flexi-stream: I just have to copy the data to temporary vector of octet buffers.

Thank you.

[avodonosov]

If anything, I am not a maintainer, just a subscribed user. Contributed some fixes in the past, so curious to look at issues sometimes.

[avodonosov]

So, in short, the issue is: flexi-streams, for input arrays whose element-type is not explicitly binary, always assumes characters. You want it instead to look at the stream element type of the flexi stream itself. Right?

That may be reasonable, especially that CLHS entry for write-sequence mentions stream element type in a way that may be interpretted to suggest such an aporoach:

Might signal an error of type type-error if an element of the bounded sequence is not a member of the stream element type of the stream.

But changing flexi-streams this way will break compatibility: somebody who was successfully performing character output on flexi-stream with element type octet will suddenly get a failure.

The most flexible would be to look at the actual type of every element, as it is currently implemented for lists, but I suppose that was avoided for arrays in a quest for higher performance.