{-# LANGUAGE OverloadedStrings #-}

-- | Module to display positive integral values as strings
module TextShow.Data.Integral.Tibetan ( builderBo
                                      , showBo) where

import qualified Data.Text.Lazy         as TL
import           Data.Text.Lazy.Builder (Builder, fromLazyText, toLazyText)

-- | Display positive integer as a `String`
--
-- > λ:> showBo 312
-- > Just "༣༡༢"
showBo :: Integer -> Maybe String
showBo :: Integer -> Maybe String
showBo = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Text -> String
TL.unpackforall b c a. (b -> c) -> (a -> b) -> a -> c
.Builder -> Text
toLazyText) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Integral a => a -> Maybe Builder
builderBo

-- | show a positive intgeger as text, return `Nothing` if that doesn't work
builderBo :: (Integral a) => a -> Maybe Builder
builderBo :: forall a. Integral a => a -> Maybe Builder
builderBo a
int
    | a
int forall a. Ord a => a -> a -> Bool
>= a
0  = forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Builder
fromLazyText forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall b c a. (b -> c) -> (a -> b) -> a -> c
(.) forall a. a -> a
id
        (forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Text -> Text -> Text -> Text
TL.replace
            (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Integer -> Text
showT [Integer
0..Integer
9])
            [Text
"༠",Text
"༡",Text
"༢",Text
"༣",Text
"༤",Text
"༥",Text
"༦",Text
"༧",Text
"༨",Text
"༩"])
        (Integer -> Text
showT (forall a b. (Integral a, Num b) => a -> b
fromIntegral a
int :: Integer))
    | Bool
otherwise = forall a. Maybe a
Nothing

showT :: Integer -> Text
showT = String -> Text
TL.pack forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Show a => a -> String
show