-- | Functions that create sentences from other data
module Language.Drasil.Sentence.Generators (
  fromSource, fterms, getTandS,
  -- this does not belong here...
  checkValidStr
  ) where

import Control.Lens ((^.))

import Language.Drasil.Classes (NamedIdea(..), Quantity)
import Language.Drasil.Development.Sentence (phrase)
import Language.Drasil.Label.Type (Referable)
import Language.Drasil.NounPhrase.Core (NP)
import Language.Drasil.Reference (refS)
import Language.Drasil.Sentence (Sentence(S),(+:+), sParen, ch)
import Language.Drasil.ShortName (HasShortName(..))

-- | Wraps "from @reference@" in parentheses.
fromSource :: (Referable r, HasShortName r) => r -> Sentence
fromSource :: forall r. (Referable r, HasShortName r) => r -> Sentence
fromSource r
r = Sentence -> Sentence
sParen (String -> Sentence
S String
"from" Sentence -> Sentence -> Sentence
+:+ r -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS r
r)

-- | Apply a binary function to the terms of two named ideas, instead of to the named
-- ideas themselves. Ex. @fterms compoundPhrase t1 t2@ instead of
-- @compoundPhrase (t1 ^. term) (t2 ^. term)@.
fterms :: (NamedIdea c, NamedIdea d) => (NP -> NP -> t) -> c -> d -> t
fterms :: forall c d t.
(NamedIdea c, NamedIdea d) =>
(NP -> NP -> t) -> c -> d -> t
fterms NP -> NP -> t
f c
a d
b = NP -> NP -> t
f (c
a c -> Getting NP c NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP c NP
forall c. NamedIdea c => Lens' c NP
Lens' c NP
term) (d
b d -> Getting NP d NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP d NP
forall c. NamedIdea c => Lens' c NP
Lens' d NP
term)

-- | Used when you want to say a term followed by its symbol. ex. "...using the Force F in...".
getTandS :: (Quantity a) => a -> Sentence
getTandS :: forall a. Quantity a => a -> Sentence
getTandS a
a = a -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase a
a Sentence -> Sentence -> Sentence
+:+ a -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch a
a

-- | Uses an 'Either' type to check if a 'String' is valid -
-- 'Left' with error message if there is an invalid 'Char' in 'String', else 'Right' with 'String'.
checkValidStr :: String -> String -> Either String String
checkValidStr :: String -> String -> Either String String
checkValidStr String
s [] = String -> Either String String
forall a b. b -> Either a b
Right String
s
checkValidStr String
s (Char
x:String
xs)
  | Char
x Char -> String -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
s = String -> Either String String
forall a b. a -> Either a b
Left (String -> Either String String) -> String -> Either String String
forall a b. (a -> b) -> a -> b
$ String
"Invalid character: \'" String -> String -> String
forall a. [a] -> [a] -> [a]
++ [Char
x] String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\' in string \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
s String -> String -> String
forall a. [a] -> [a] -> [a]
++ [Char
'\"']
  | Bool
otherwise  = String -> String -> Either String String
checkValidStr String
s String
xs