purescript-strings/src/Data/String/NonEmpty/CodePoints.purs at master · purescript/purescript-strings · GitHub - github.com

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
module Data.String.NonEmpty.CodePoints
  ( fromCodePointArray
  , fromNonEmptyCodePointArray
  , singleton
  , cons
  , snoc
  , fromFoldable1
  , toCodePointArray
  , toNonEmptyCodePointArray
  , codePointAt
  , indexOf
  , indexOf'
  , lastIndexOf
  , lastIndexOf'
  , uncons
  , length
  , take
  -- takeRight
  , takeWhile
  , drop
  -- dropRight
  , dropWhile
  , countPrefix
  , splitAt
  ) where

import Prelude

import Data.Array.NonEmpty (NonEmptyArray)
import Data.Array.NonEmpty as NEA
import Data.Maybe (Maybe(..), fromJust)
import Data.Semigroup.Foldable (class Foldable1)
import Data.Semigroup.Foldable as F1
import Data.String.CodePoints (CodePoint)
import Data.String.CodePoints as CP
import Data.String.NonEmpty.Internal (NonEmptyString(..), fromString)
import Data.String.Pattern (Pattern)
import Partial.Unsafe (unsafePartial)

-- For internal use only. Do not export.
toNonEmptyString :: String -> NonEmptyString
toNonEmptyString = NonEmptyString

-- For internal use only. Do not export.
fromNonEmptyString :: NonEmptyString -> String
fromNonEmptyString (NonEmptyString s) = s

-- For internal use only. Do not export.
liftS :: forall r. (String -> r) -> NonEmptyString -> r
liftS f (NonEmptyString s) = f s

fromCodePointArray :: Array CodePoint -> Maybe NonEmptyString
fromCodePointArray = case _ of
  [] -> Nothing
  cs -> Just (toNonEmptyString (CP.fromCodePointArray cs))

fromNonEmptyCodePointArray :: NonEmptyArray CodePoint -> NonEmptyString
fromNonEmptyCodePointArray = unsafePartial fromJust <<< fromCodePointArray <<< NEA.toArray

singleton :: CodePoint -> NonEmptyString
singleton = toNonEmptyString <<< CP.singleton

cons :: CodePoint -> String -> NonEmptyString
cons c s = toNonEmptyString (CP.singleton c <> s)

snoc :: CodePoint -> String -> NonEmptyString
snoc c s = toNonEmptyString (s <> CP.singleton c)

fromFoldable1 :: forall f. Foldable1 f => f CodePoint -> NonEmptyString
fromFoldable1 = F1.foldMap1 singleton

toCodePointArray :: NonEmptyString -> Array CodePoint
toCodePointArray = CP.toCodePointArray <<< fromNonEmptyString

toNonEmptyCodePointArray :: NonEmptyString -> NonEmptyArray CodePoint
toNonEmptyCodePointArray = unsafePartial fromJust <<< NEA.fromArray <<< toCodePointArray

codePointAt :: Int -> NonEmptyString -> Maybe CodePoint
codePointAt = liftS <<< CP.codePointAt

indexOf :: Pattern -> NonEmptyString -> Maybe Int
indexOf = liftS <<< CP.indexOf

indexOf' :: Pattern -> Int -> NonEmptyString -> Maybe Int
indexOf' pat = liftS <<< CP.indexOf' pat

lastIndexOf :: Pattern -> NonEmptyString -> Maybe Int
lastIndexOf = liftS <<< CP.lastIndexOf

lastIndexOf' :: Pattern -> Int -> NonEmptyString -> Maybe Int
lastIndexOf' pat = liftS <<< CP.lastIndexOf' pat

uncons :: NonEmptyString -> { head :: CodePoint, tail :: Maybe NonEmptyString }
uncons nes =
  let
    s = fromNonEmptyString nes
  in
    { head: unsafePartial fromJust (CP.codePointAt 0 s)
    , tail: fromString (CP.drop 1 s)
    }

length :: NonEmptyString -> Int
length = CP.length <<< fromNonEmptyString

take :: Int -> NonEmptyString -> Maybe NonEmptyString
take i nes =
  let
    s = fromNonEmptyString nes
  in
    if i < 1
      then Nothing
      else Just (toNonEmptyString (CP.take i s))

takeWhile :: (CodePoint -> Boolean) -> NonEmptyString -> Maybe NonEmptyString
takeWhile f = fromString <<< liftS (CP.takeWhile f)

drop :: Int -> NonEmptyString -> Maybe NonEmptyString
drop i nes =
  let
    s = fromNonEmptyString nes
  in
    if i >= CP.length s
      then Nothing
      else Just (toNonEmptyString (CP.drop i s))

dropWhile :: (CodePoint -> Boolean) -> NonEmptyString -> Maybe NonEmptyString
dropWhile f = fromString <<< liftS (CP.dropWhile f)

countPrefix :: (CodePoint -> Boolean) -> NonEmptyString -> Int
countPrefix = liftS <<< CP.countPrefix

splitAt
  :: Int
  -> NonEmptyString
  -> { before :: Maybe NonEmptyString, after :: Maybe NonEmptyString }
splitAt i nes =
  case CP.splitAt i (fromNonEmptyString nes) of
    { before, after } -> { before: fromString before, after: fromString after }