Cindiary / elm-not-empty / NotEmpty.String

Strings


type alias String =
( Char
, Internal.CoreTypes.CoreString 
)

Not empty version of String

fromString : Internal.CoreTypes.CoreString -> Maybe String

Convert a regular string into a not empty string, or Nothing if the string is empty

fromString "" == Nothing
fromString "hello" == Just ( consString 'h' "ello" )

toString : String -> Internal.CoreTypes.CoreString

Convert a not empty string into a regular string

toString ( consString 'h' "ello" ) == "hello" toString ( consString 'a' "" ) == "a"

length : String -> Basics.Int

Same as String.length

reverse : String -> String

Same as String.reverse

repeat : Basics.Int -> String -> String

Same as String.repeat but the string is repeated at least once

replace : String -> String -> String -> String

Same as String.replace

Building and Splitting

append : String -> String -> String

Same as String.append

appendString : String -> Internal.CoreTypes.CoreString -> String

Append a regular string to a not empty string

appendToString : Internal.CoreTypes.CoreString -> String -> String

Append a not empty string to a regular string

concat : NotEmpty.List.List String -> String

Same as String.concat

split : String -> String -> NotEmpty.List.List Internal.CoreTypes.CoreString

Same as String.split, returns regular strings

join : Internal.CoreTypes.CoreString -> NotEmpty.List.List String -> String

Same as String.join

words : String -> List String

Same as String.words but will not return empty words

lines : String -> List Internal.CoreTypes.CoreString

Same as String.lines, returns regular strings

Get Substrings

slice : Basics.Int -> Basics.Int -> String -> Maybe String

Same as String.slice

left : Basics.Int -> String -> String

Same as String.left but will take at least 1 character

right : Basics.Int -> String -> String

Same as String.right but will take at least 1 character

dropLeft : Basics.Int -> String -> Maybe String

Same as String.dropLeft

dropRight : Basics.Int -> String -> Maybe String

Same as String.dropRight

Check for Substrings

contains : String -> String -> Basics.Bool

Same as String.contains

startsWith : String -> String -> Basics.Bool

Same as String.startsWith

endsWith : String -> String -> Basics.Bool

Same as String.endsWith

indexes : String -> String -> List Basics.Int

Same as String.indexes

indices : String -> String -> List Basics.Int

Alias for indexes.

Int Conversions

toInt : String -> Maybe Basics.Int

Same as String.toInt

fromInt : Basics.Int -> String

Same as String.fromInt

Float Conversions

toFloat : String -> Maybe Basics.Float

Same as String.toFloat

fromFloat : Basics.Float -> String

Same as String.fromFloat

Char Conversions

fromChar : Char -> String

Same as String.fromChar

cons : Char -> String -> String

Same as String.cons

consString : Char -> Internal.CoreTypes.CoreString -> String

Create a not empty string from a char and a regular string

uncons : String -> ( Char, Internal.CoreTypes.CoreString )

Same as String.uncons, but always returns a value

head : String -> Char

Get the first character from a not empty string

head ( consString 'h' "ello" ) == 'h'

tail : String -> Internal.CoreTypes.CoreString

Get the tail from a not empty string

tail ( consString 'h' "ello" ) == "ello"

List Conversions

toList : String -> NotEmpty.List.List Char

Same as String.toList, returns a not empty list

fromList : NotEmpty.List.List Char -> String

Same as String.fromList, but takes a not empty list

Formatting

Cosmetic operations such as padding with extra characters or trimming whitespace.

toUpper : String -> String

Same as String.toUpper

toLower : String -> String

Same as String.toLower

pad : Basics.Int -> Char -> String -> String

Same as String.pad

padLeft : Basics.Int -> Char -> String -> String

Same as String.padLeft

padRight : Basics.Int -> Char -> String -> String

Same as String.padRight

trim : String -> Maybe String

Same as String.trim

trimLeft : String -> Maybe String

Same as String.trimLeft

trimRight : String -> Maybe String

Same as String.trimRight

Higher-Order Functions

map : (Char -> Char) -> String -> String

Same as String.map

filter : (Char -> Basics.Bool) -> String -> Maybe String

Same as String.filter

foldl : (Char -> b -> b) -> b -> String -> b

Same as String.foldl

foldr : (Char -> b -> b) -> b -> String -> b

Same as String.foldr

any : (Char -> Basics.Bool) -> String -> Basics.Bool

Same as String.any

all : (Char -> Basics.Bool) -> String -> Basics.Bool

Same as String.all