Data.String

base-4.11.1.0: Basic libraries

Copyright | (c) The University of Glasgow 2007
License | BSD-style (see the file libraries/base/LICENSE)
Maintainer | libraries@haskell.org
Stability | experimental
Portability | portable
Safe Haskell | Trustworthy
Language | Haskell2010

Data.String

Contents

- Functions on strings

Description

The `String` type and associated operations.

Synopsis

- type String = [Char]
- class IsString a where
- lines :: String -> [String]
- words :: String -> [String]
- unlines :: [String] -> String
- unwords :: [String] -> String

# Documentation

type String = [Char] #

A `String` is a list of characters. String constants in Haskell are values of type `String`.

class IsString a where #

Class for string-like datastructures; used by the overloaded string extension (-XOverloadedStrings in GHC).

Minimal complete definition

fromString

Methods

fromString :: String -> a #

Instances

a ~ Char => IsString [a] # | `(a ~ Char)` context was introduced in `4.9.0.0` Since: base-2.1
Instance details Defined in Data.String Methods fromString :: String -> [a] #
IsString a => IsString (Identity a) # |
Instance details Defined in Data.String Methods fromString :: String -> Identity a #
IsString a => IsString (Const a b) # | Since: base-4.9.0.0
Instance details Defined in Data.String Methods fromString :: String -> Const a b #

# Functions on strings

lines :: String -> [String] #

`lines` breaks a string up into a list of strings at newline characters. The resulting strings do not contain newlines.

Note that after splitting the string at newline characters, the last part of the string is considered a line even if it doesn't end with a newline. For example,

    >>> lines ""
    []

    >>> lines "\n"
    [""]

    >>> lines "one"
    ["one"]

    >>> lines "one\n"
    ["one"]

    >>> lines "one\n\n"
    ["one",""]

    >>> lines "one\ntwo"
    ["one","two"]

    >>> lines "one\ntwo\n"
    ["one","two"]

Thus ``lines` s` contains at least as many elements as newlines in `s`.

words :: String -> [String] #

`words` breaks a string up into a list of words, which were delimited by white space.

    >>> words "Lorem ipsum\ndolor"
    ["Lorem","ipsum","dolor"]

unlines :: [String] -> String #

`unlines` is an inverse operation to `lines`. It joins lines, after appending a terminating newline to each.

    >>> unlines ["Hello", "World", "!"]
    "Hello\nWorld\n!\n"

unwords :: [String] -> String #

`unwords` is an inverse operation to `words`. It joins words with separating spaces.

    >>> unwords ["Lorem", "ipsum", "dolor"]
    "Lorem ipsum dolor"