{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
#if __GLASGOW_HASKELL__ >= 800
{-# OPTIONS_GHC -Wno-redundant-constraints #-}
#endif
module Data.StaticText
(
create
, createLeft
, createRight
, st
, replicate
, append
, take
, drop
, map
, padLeft
, padRight
, length
, Static
, IsStaticText(Elem, unsafeCreate, unwrap)
)
where
import Prelude as P hiding (drop, length, map, replicate, take)
import GHC.TypeLits
import Data.Proxy
import Data.StaticText.Class (Elem, Static, IsStaticText)
import qualified Data.StaticText.Class as C
import Data.StaticText.TH
createLeft :: forall a i.
(IsStaticText a, KnownNat i) =>
Elem a -> a -> Static a i
createLeft e s =
C.unsafeCreate $
C.take t $
C.append s $
C.replicate (t - C.length s) e
where
t = fromIntegral $ natVal (Proxy :: Proxy i)
createRight :: forall a i.
(IsStaticText a, KnownNat i) =>
Elem a -> a -> Static a i
createRight e s =
C.unsafeCreate $
C.drop (C.length s - t) $
C.append (C.replicate (t - C.length s) e) s
where
t = fromIntegral $ natVal (Proxy :: Proxy i)
create :: forall a i.
(IsStaticText a, KnownNat i) =>
a -> P.Maybe (Static a i)
create s =
if C.length s == t
then Just $ C.unsafeCreate s
else Nothing
where
t = fromIntegral $ natVal (Proxy :: Proxy i)
append :: forall a m n.
(IsStaticText a) => Static a m -> Static a n -> Static a (m + n)
append a b = C.unsafeCreate $ C.append (C.unwrap a) (C.unwrap b)
replicate :: forall a i.
(IsStaticText a, KnownNat i) => Elem a -> Static a i
replicate e =
C.unsafeCreate $ C.replicate t e
where
t = fromIntegral $ natVal (Proxy :: Proxy i)
map :: IsStaticText a =>
(Elem a -> Elem a) -> Static a m -> Static a m
map f s =
C.unsafeCreate $ C.map f $ C.unwrap s
take :: forall a m n.
(IsStaticText a, KnownNat m, KnownNat n, n <= m) =>
Static a m -> Static a n
take s =
C.unsafeCreate $ C.take t $ C.unwrap s
where
t = fromIntegral $ natVal (Proxy :: Proxy n)
drop :: forall a m n.
(IsStaticText a, KnownNat m, KnownNat n, n <= m) =>
Static a m -> Static a n
drop s =
C.unsafeCreate $ C.drop (C.length s' - t) s'
where
s' = C.unwrap s
t = fromIntegral $ natVal (Proxy :: Proxy n)
length :: forall a m.
KnownNat m => Static a m -> P.Int
length _ = P.fromIntegral P.$ natVal (Proxy :: Proxy m)
padLeft :: forall a m n.
(IsStaticText a, KnownNat m, KnownNat (n - m),
n ~ (n - m + m), m <= n) =>
Elem a -> Static a m -> Static a n
padLeft pad = append (replicate pad)
padRight :: forall a m n.
(IsStaticText a, KnownNat m, KnownNat (n - m),
n ~ (m + (n - m)), m <= n) =>
Elem a -> Static a m -> Static a n
padRight pad = P.flip append (replicate pad)