An Encode converts its argument into one or more textual fields, to be written out as CSV.

It is Semigroup, Contravariant', Divisible, and Decidable, allowing for composition of these values to build bigger Encodes from smaller ones.

Make an Encode from a function that builds one Field.

Make an Encode from a function that builds one Field.

Make an encode from any function that returns a ByteString Builder.

Encode the given list with the given Encode, configured by the given EncodeOptions.

Encode, writing the output to a file handle.

Encode, writing to a file. This is way is more efficient than encoding to a ByteString and then writing to file.

Encode to a ByteString Builder, which is useful if you are going to combine the output with other ByteStrings.

Encode one row only

Encode one row only, as a ByteString Builder

Build an Sv rather than going straight to ByteString. This allows you to query the Sv or run sanity checks.

Encode this ByteString every time, ignoring the input.

Build an Encode using a type's Show instance.

Don't encode anything.

Encode anything as the empty string.

Lift an Encode to be able to hanlde Maybe, by using the empty string in the case of Nothing

Encode a single Char

Encode an Int

Encode an Integer

Encode a Float

Encode a Double

Encode a Bool as False or True

Encode a Bool as false or true

Encode a Bool as no or yes

Encode a Bool as No or Yes

Encode a Bool as N or Y

Encode a Bool as 0 or 1

Encode a String

Encode a Text

Encode a strict ByteString

Encode a lazy ByteString

Encode a list as a whole row at once, using the same Encode for every element

Build an Encode for Maybe given a Just and a Nothing encode.

Build an Encode for Maybe given a Nothing and a Just encode.

Build an Encode for Maybe given a Just encode and a ByteString for the Nothing case.

Build an Encode for Maybe given a ByteString for the Nothing case and a Just encode.

Given an optic from s to a, Try to use it to build an encode.

encodeOf :: Iso'       s a -> Encode a -> Encode s
encodeOf :: Lens'      s a -> Encode a -> Encode s
encodeOf :: Prism'     s a -> Encode a -> Encode s
encodeOf :: Traversal' s a -> Encode a -> Encode s
encodeOf :: Fold       s a -> Encode a -> Encode s
encodeOf :: Getter     s a -> Encode a -> Encode s

This is very useful when you have a prism for each constructor of your type. You can define an Encode as follows:

myEitherEncode :: Encode a -> Encode b -> Encode (Either a b)
myEitherEncode encA encB = encodeOf _Left encA <> encodeOf _Right encB

In this example, when the prism lookup returns Nothing, the empty encoder is returned. This is the mempty for the Encode monoid, so it won't add a field to the resulting CSV. This is the behaviour you want for combining a collection of prisms.

But this encoder also works with lenses (or weaker optics), which will never fail their lookup, in which case it never returns mempty. So this actually does the right thing for both sum and product types.

Like encodeOf, but you can handle Nothing however you'd like. In encodeOf, it is handled by the Encode which does nothing, but for example you might like to use orEmpty to encode an empty field.

Encode a String really quickly. If the string has quotes in it, they will not be escaped properly, so the result maybe not be valid CSV

Encode Text really quickly. If the text has quotes in it, they will not be escaped properly, so the result maybe not be valid CSV

Encode a ByteString really quickly. If the string has quotes in it, they will not be escaped properly, so the result maybe not be valid CSV

Encode a ByteString really quickly. If the string has quotes in it, they will not be escaped properly, so the result maybe not be valid CSV

Encode ByteString Builder really quickly. If the builder builds a string with quotes in it, they will not be escaped properly, so the result maybe not be valid CSV

Encode this ByteString really quickly every time, ignoring the input. If the string has quotes in it, they will not be escaped properly, so the result maybe not be valid CSV