Std.Bytes

45 public declarations

• at&Bytes -> Int -> Option[UInt8]

  The byte at a position, or nothing when the position is outside.

  fn
• BytesError

  What went wrong while reading a byte sequence.

  type
• concat&Bytes -> &Bytes -> Bytes

  Two sequences joined. This copies, and is named so a reader can see it.

  fn
• contains&Bytes -> &Bytes -> Bool

  Whether a sub-sequence appears anywhere.

  fn
• decodeBase64Str -> Result[Bytes, Std.Bytes.BytesError]

  The bytes base64 text spells, or why it spells none.

  fn
• decodeBase64UrlStr -> Result[Bytes, Std.Bytes.BytesError]

  The bytes URL-alphabet base64 spells, padded or not.

  fn
• decodeHexStr -> Result[Bytes, Std.Bytes.BytesError]

  The bytes hexadecimal text spells, or why it spells none.

  fn
• drop&Bytes -> Int -> Bytes

  Everything after the first bytes, sharing storage with the source.

  fn
• emptyBytes

  A sequence holding nothing.

  fn
• encodeBase64&Bytes -> Str

  A sequence written as base64, padded to a multiple of four characters.

  fn
• encodeBase64Url&Bytes -> Str

  A sequence written as base64 in the alphabet a URL admits, unpadded.

  fn
• encodeHex&Bytes -> Str

  A sequence written as lower-case hexadecimal, two digits a byte.

  fn
• endsWith&Bytes -> &Bytes -> Bool

  Whether a sequence ends with another.

  fn
• fromArray&Array[UInt8] -> Bytes

  The bytes of an array of octets.

  fn
• fromTextStr -> Bytes

  The UTF-8 encoding of text. This direction cannot fail.

  fn
• getBytes&Bytes -> Int -> Result[(Bytes, Bytes), Std.Bytes.BytesError]

  The next bytes as their own sequence, and the rest of the input.

  fn
• getText&Bytes -> Int -> Result[(Str, Bytes), Std.Bytes.BytesError]

  The next bytes decoded as text, and the rest of the input.

  fn
• getU16Be&Bytes -> Result[(UInt16, Bytes), Std.Bytes.BytesError]

  Two bytes as a number, most significant first, and the rest of the input.

  fn
• getU16Le&Bytes -> Result[(UInt16, Bytes), Std.Bytes.BytesError]

  Two bytes as a number, least significant first, and the rest of the input.

  fn
• getU32Be&Bytes -> Result[(UInt32, Bytes), Std.Bytes.BytesError]

  Four bytes as a number, most significant first, and the rest of the input.

  fn
• getU32Le&Bytes -> Result[(UInt32, Bytes), Std.Bytes.BytesError]

  Four bytes as a number, least significant first, and the rest of the input.

  fn
• getU64Be&Bytes -> Result[(UInt64, Bytes), Std.Bytes.BytesError]

  Eight bytes as a number, most significant first, and the rest of the input.

  fn
• getU64Le&Bytes -> Result[(UInt64, Bytes), Std.Bytes.BytesError]

  Eight bytes as a number, least significant first, and the rest of the input.

  fn
• getU8&Bytes -> Result[(UInt8, Bytes), Std.Bytes.BytesError]

  One byte, and the rest of the input.

  fn
• indexOf&Bytes -> &Bytes -> Int

  Where a sub-sequence begins, or `-1` when it is absent.

  fn
• isEmpty&Bytes -> Bool

  Whether a sequence holds nothing.

  fn
• join&Array[Bytes] -> Bytes

  Every sequence joined in order.

  fn
• length&Bytes -> Int

  How many bytes a sequence holds.

  fn
• putU16BeUInt16 -> Bytes

  Two bytes written, most significant first.

  fn
• putU16LeUInt16 -> Bytes

  Two bytes written, least significant first.

  fn
• putU32BeUInt32 -> Bytes

  Four bytes written, most significant first.

  fn
• putU32LeUInt32 -> Bytes

  Four bytes written, least significant first.

  fn
• putU64BeUInt64 -> Bytes

  Eight bytes written, most significant first.

  fn
• putU64LeUInt64 -> Bytes

  Eight bytes written, least significant first.

  fn
• putU8UInt8 -> Bytes

  One byte written.

  fn
• repeat&Bytes -> Int -> Bytes

  A sequence repeated, or nothing repeated when the count is not positive.

  fn
• reverse&Bytes -> Bytes

  A sequence in reverse. This copies.

  fn
• slice&Bytes -> Int -> Int -> Bytes

  The stretch between two positions, sharing storage with its source.

  fn
• split&Bytes -> &Bytes -> Array[Bytes]

  The pieces between each appearance of a separator.

  fn
• splitAt&Bytes -> Int -> (Bytes, Bytes)

  A sequence cut in two at a position, both halves sharing its storage.

  fn
• startsWith&Bytes -> &Bytes -> Bool

  Whether a sequence begins with another.

  fn
• take&Bytes -> Int -> Bytes

  The first bytes of a sequence, sharing storage with it.

  fn
• toArray&Bytes -> Array[UInt8]

  The octets of a sequence, one value per byte.

  fn
• toText&Bytes -> Result[Str, Std.Bytes.BytesError]

  The text a sequence encodes, or the reason it is not text.

  fn
• xorWith&Bytes -> &Bytes -> Bytes

  Two sequences combined bit by bit, as long as the shorter of them.

  fn