lue-bird / elm-morph / AToZ.Morph

Morph for a basic latin letter a|...|z

Morph

only : AToZ -> Morph () AToZ

Match only the specific given broad input. See Morph.only

broadCase : AToZ.Case -> Morph AToZ { case_ : AToZ.Case, letter : AToZ }

Morph that when calling toBroad always returns a letter with a given Case.

For any more complex toBroad process, use oneToOne

For the general idea, check out Morph.broad

Example: We want to format it as lowercase but also accept uppercase:

AToZ.broadCase AToZ.CaseLower
    |> Morph.over AToZ.Morph.char

which would be equivalent to

Morph.oneToOne .letter (\letter -> { letter = letter, case_ = AToZ.CaseLower })
    |> Morph.over AToZ.Morph.char

lowerChar : Morph AToZ Char

Match a lowercase letter Char.

ℹ️ Equivalent regular expression: [a-z]

import Morph
import List.Morph
import AToZ exposing (AToZ(..))

-- match a lowercase letter
'a' |> Morph.toNarrow AToZ.Morph.lowerChar
--> Ok A

-- but anything else makes it fail
'A'
    |> Morph.toNarrow AToZ.Morph.lowerChar
    |> Result.toMaybe
--> Nothing

Combine with Morph.one to use it in a MorphRow

This is different from

AToZ.Morph.broadCase AToZ.CaseLower
    |> Morph.over AToZ.Morph.char

which parses any case but only prints lowercase

upperChar : Morph AToZ Char

Match an uppercase letter Char.

ℹ️ Equivalent regular expression: [A-Z]

import Morph
import List.Morph
import AToZ exposing (AToZ(..))

-- match an uppercase a-z letter
'A' |> Morph.toNarrow AToZ.Morph.upperChar
--> Ok A

-- but anything else makes it fail
'a'
    |> Morph.toNarrow AToZ.Morph.upperChar
    |> Result.toMaybe
--> Nothing

Combine with Morph.one to use it in a MorphRow

This is different from

AToZ.Morph.broadCase AToZ.CaseUpper
    |> Morph.over AToZ.Morph.char

which parses any case but only prints uppercase

char : Morph { case_ : AToZ.Case, letter : AToZ } Char

Morph a letter AToZ and its Case from a Char

ℹ️ Equivalent regular expression: [a-zA-Z]

import AToZ

-- match any letter, remembering the case
'a' |> Morph.toNarrow AToZ.Morph.char
--> Ok { case_ = AToZ.CaseLower, letter = AToZ.A }

'A' |> Morph.toNarrow AToZ.Morph.char
--> Ok { case_ = AToZ.CaseUpper, letter = AToZ.A }

-- digits, symbols etc makes it fail
'1'
    |> Morph.toNarrow AToZ.Morph.char
    |> Result.toMaybe
--> Nothing

Combine with broadCase to provide a default casing on toBroad

Combine with Morph.one to use it in a MorphRow

example Morph.whilePossible (AToZ.Morph.char |> Morph.one)

ℹ️ Equivalent regular expression: [a-zA-Z]*

import Morph
import List.Morph

-- multiple letters, remembering their cases
"aBc"
    |> Morph.toNarrow
        (Morph.whilePossible (AToZ.Morph.char |> Morph.one)
            |> Morph.rowFinish
            |> Morph.over List.Morph.string
        )
--> Ok
-->     [ { case_ = AToZ.CaseLower, letter = AToZ.A }
-->     , { case_ = AToZ.CaseUpper, letter = AToZ.B }
-->     , { case_ = AToZ.CaseLower, letter = AToZ.C }
-->     ]

-- greek letters, space, -, ', . etc are not [a-Z]
"abπc"
    |> Morph.toNarrow
        (Morph.broad []
            |> Morph.overRow
                (Morph.whilePossible (AToZ.Morph.char |> Morph.one))
            |> Morph.rowFinish
            |> Morph.over List.Morph.string
        )
    |> Result.toMaybe
--> Nothing