implement Enum Text and lowercase, uppercase conversion.

Can we add to the stdlib:

ub : Int
ub = 1114112 -- = 17 * 65,536

cplToI : [Int] -> Int
cplToI l = fst $ foldl u (0, 1) l
  where u (a, p) i = (a + i * p, p * ub)

iToCplAcc : [Int] -> Int -> [Int]
iToCplAcc acc i =
  let d = i / ub in
  if d == 0 then
    i :: acc
  else
    iToCplAcc (i::acc) (i - d * ub)

iToCpl : Int -> [Int]
iToCpl = iToCplAcc []

instance Enum Text where
  fromEnum = cplToI . toCodePoints
  toEnum = fromCodePoints . iToCpl

my goal is to also add

ia = fromEnum "a"
iz = fromEnum "z"

iA = fromEnum "A"
iZ = fromEnum "Z"

toUpperAsciiChar : Text -> Text
toUpperAsciiChar c
  | ia <= ic && ic <= iz = toEnum (ic + (iA - ia))
  | otherwise = c
      where ic = fromEnum c

toLowerAsciiChar : Text -> Text
toLowerAsciiChar c
  | iA <= ic && ic <= iZ = toEnum (ic - (iA - ia))
  | otherwise = c
      where ic = fromEnum c

toUpper : Text -> Text
toUpper = implode . fmap toUpperAsciiChar . explode

toLower : Text -> Text
toLower = implode . fmap toLowerAsciiChar . explode

But if there are primitives that we can leverage that accomplish toLower and toUpper better (ala explode), that would be great.

[remyhaemmerle-da]

@leonidr-da I have never said, there is no legitimate use cases 😉. I even supported you for adding some functions to the standard library. I am just a bit reluctant to add new LF primitives each time we find Daml too slow.

On the one hand, adding primitives does not solve the intrinsic problem of slowness, but just circumvent it in some particular use cases, while increasing maintenance cost. On the other hand, solving really Daml slowness will require rewriting the interpreter, the fewer primitives we have the easier this task will be.

[cocreature]

Adding it to the standard library seems very reasonable to me. I agree with @remyhaemmerle-da that we should be careful wtr to primitives. I do expect that we’ll want to expand the set of Text primitives at some point but I’d rather do that in one go accompanied by design & benchmark work to only add the ones that really pay off instead of adding more and more primitives over time.