serial - python string to bytestring

¿Cuál es la mejor manera de convertir String a ByteString?

Question

¿Cuál es la mejor manera de convertir una Cadena a una ByteString en Haskell?

Mi reacción al problema es

import qualified Data.ByteString as B
import Data.Char (ord)

packStr = B.pack . map (fromIntegral . ord)

Pero esto no parece satisfactorio.

Answer 1

Aquí está mi hoja de trucos para la conversión estricta / lenta de Haskell String / Text / ByteString suponiendo que la codificación deseada es UTF-8. La biblioteca Data.Text.Encoding tiene otras codificaciones disponibles.

Por favor, asegúrese de no escribir (utilizando OverloadedStrings):

lazyByteString :: BL.ByteString
lazyByteString = "lazyByteString ä ß" -- BAD!

Esto se codificará de una manera inesperada. Tratar

lazyByteString = BLU.fromString "lazyByteString ä ß" -- good

en lugar.

Los literales de cadena de tipo ''Texto'' funcionan bien con respecto a la codificación.

Hoja de trucos:

import Data.ByteString.Lazy as BL
import Data.ByteString as BS
import Data.Text as TS
import Data.Text.Lazy as TL
import Data.ByteString.Lazy.UTF8 as BLU
import Data.ByteString.UTF8 as BSU
import Data.Text.Encoding as TSE
import Data.Text.Lazy.Encoding as TLE

-- String <-> ByteString

BLU.toString   :: BL.ByteString -> String
BLU.fromString :: String -> BL.ByteString
BSU.toString   :: BS.ByteString -> String
BSU.fromString :: String -> BS.ByteString

-- String <-> Text

TL.unpack :: TL.Text -> String
TL.pack   :: String -> TL.Text
TS.unpack :: TS.Text -> String
TS.pack   :: String -> TS.Text

-- ByteString <-> Text

TLE.encodeUtf8 :: TL.Text -> BL.ByteString
TLE.decodeUtf8 :: BL.ByteString -> TL.Text
TSE.encodeUtf8 :: TS.Text -> BS.ByteString
TSE.decodeUtf8 :: BS.ByteString -> TS.Text

-- Lazy <-> Strict

BL.fromStrict :: BS.ByteString -> BL.ByteString
BL.toStrict   :: BL.ByteString -> BS.ByteString
TL.fromStrict :: TS.Text -> TL.Text
TL.toStrict   :: TL.Text -> TS.Text

Por favor, +1 la respuesta de Peaker, porque trata correctamente con la codificación.

Answer 2

Data.ByteString.UTF8.fromString también es útil. La versión Char8 perderá la unicode-ness y UTF8 hará un ByteString codificado en UTF8. Tienes que elegir uno u otro.

Answer 3

Un enfoque seguro implicará la codificación de la cadena Unicode:

import qualified Data.ByteString as B
import qualified Data.Text as T
import Data.Text.Encoding (encodeUtf8)

packStr'''' :: String -> B.ByteString
packStr'''' = encodeUtf8 . T.pack

Con respecto a las otras respuestas: Data.ByteString.Char8.pack es efectivamente la misma que la versión de la pregunta y es poco probable que sea lo que usted desea:

import qualified Data.ByteString as B
import qualified Data.ByteString.Char8 as C
import qualified Data.Text as T
import Data.Text.Encoding (encodeUtf8)
import Data.Char (ord)

packStr, packStr'', packStr'''' :: String -> B.ByteString
packStr   = B.pack . map (fromIntegral . ord)
packStr''  = C.pack
packStr'''' = encodeUtf8 . T.pack

*Main> packStr "hellö♥"
"hell/246e"
*Main> packStr'' "hellö♥"
"hell/246e"
*Main> packStr'''' "hellö♥"
"hell/195/182/226/153/165"

Data.ByteString.UTF8.fromString está bien, pero requiere el paquete utf8-string, mientras que Data.Text.Encoding viene con la plataforma Haskell.

Answer 4

Data.ByteString[.Lazy].Char8.pack

Por lo general, puedes usar hoogle para encontrar funciones.