homepage: https://github.com/clovyr/string-fromto
changelog-type: markdown
hash: 8c8ee0d8d0b606ac65e06c8e0c93d99ac0e18edc9af3aea4dbec10dbf44859c3
test-bench-deps: {}
maintainer: patrick@clovyr.io
synopsis: Conversions between common string types, as well as Base16/Base32/Base64.
changelog: |
  # 1.0.0.0

  Initial version
basic-deps:
  bytestring: ! '>=0.10.4.0 && <0.11'
  base: ! '>=4.8.2.0 && <5'
  text: ! '>=0.1 && <1.3'
  memory: ! '>=0.8 && <0.16'
all-versions:
- 1.0.0.0
author: Patrick Nielsen
latest: 1.0.0.0
description-type: markdown
description: |
  # string-fromto

  A collection of predictably-named functions (e.g. byteStringToString) that
  convert between the common string types, as well as to and from Base16, Base32,
  and Base64.

  ## Usage

  ```haskell
  import Data.String.FromTo -- or imported as part of your Prelude

  str :: String
  str = "Hi, I'm a string"

  text :: Text
  text = stringToText str

  encoded :: ByteString
  encoded = textToBase64ByteString text

  decoded :: Either String Text
  decoded = base64ByteStringToText encoded
  ```

  ## Documentation

  [Hackage](https://hackage.haskell.org/package/string-fromto)

  ## License

  [BSD3](LICENSE)

  ## Motivation

  Have you ever found yourself frustrated that you're spending 15-30% of your
  time in Haskell converting between string types, remembering which module has
  the `toStrict` function, importing Data.Text.Encoding and
  Data.Text.Lazy.Encoding qualified, spending time thinking about how to do
  Base64 encoding, etc.? Or tried to use one of the (excellent) typeclass-based
  string conversion libraries, only to find yourself adding awkward type
  signatures to avoid type-inferencing ambiguities?

  This library exports a collection of functions that follow a simple pattern:

  ```haskell
  stringTypeAToStringTypeB :: a -> b
  ```

  For example:

  ```haskell

  stringToByteString :: String -> ByteString

  stringToLazyByteString :: String -> Lazy.ByteString

  base64ByteStringToText :: ByteString -> Either String Text
  ```

  This way, if you import this module unqualified, or as part of your Prelude,
  all you have to think about is which type you want to convert into which other
  type.

  (Note that not *every* possible permutation has a function, just each one we've
  ever needed. If you need one that's not included, please submit a pull request
  to add it.)
license-name: BSD-3-Clause

Update from Hackage at 2019-09-30T17:34:20Z
Update from Hackage at 2019-09-30T17:34:20Z
