{-# LANGUAGE DataKinds            #-}
{-# LANGUAGE FlexibleContexts     #-}
{-# LANGUAGE FlexibleInstances    #-}
{-# LANGUAGE OverloadedStrings    #-}
{-# LANGUAGE TypeSynonymInstances #-}

-- | PureScript types to be used for bridges, e.g. in "Language.PureScript.Bridge.Primitives".
module Language.PureScript.Bridge.PSTypes where

import           Control.Lens                        (views)
import qualified Data.Text                           as T
import           Control.Monad.Reader.Class


import           Language.PureScript.Bridge.Builder
import           Language.PureScript.Bridge.TypeInfo

-- | Uses  type parameters from 'haskType' (bridged).
psArray :: MonadReader BridgeData m => m PSType
psArray :: forall (m :: * -> *). MonadReader BridgeData m => m PSType
psArray = forall (lang :: Language).
Text -> Text -> Text -> [TypeInfo lang] -> TypeInfo lang
TypeInfo Text
"" Text
"Prim" Text
"Array" forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadReader BridgeData m => m [PSType]
psTypeParameters

psBool :: PSType
psBool :: PSType
psBool = TypeInfo {
    _typePackage :: Text
_typePackage = Text
""
  , _typeModule :: Text
_typeModule = Text
"Prim"
  , _typeName :: Text
_typeName = Text
"Boolean"
  , _typeParameters :: [PSType]
_typeParameters = []
  }

-- | Uses  type parameters from 'haskType' (bridged).
psEither :: MonadReader BridgeData m => m PSType
psEither :: forall (m :: * -> *). MonadReader BridgeData m => m PSType
psEither = forall (lang :: Language).
Text -> Text -> Text -> [TypeInfo lang] -> TypeInfo lang
TypeInfo Text
"purescript-either" Text
"Data.Either" Text
"Either" forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadReader BridgeData m => m [PSType]
psTypeParameters

psObject :: MonadReader BridgeData m => m PSType
psObject :: forall (m :: * -> *). MonadReader BridgeData m => m PSType
psObject = do
  [PSType]
valueTypes <- forall a. [a] -> [a]
tail forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadReader BridgeData m => m [PSType]
psTypeParameters
  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (lang :: Language).
Text -> Text -> Text -> [TypeInfo lang] -> TypeInfo lang
TypeInfo Text
"purescript-foreign-object" Text
"Foreign.Object" Text
"Object" [PSType]
valueTypes

psInt :: PSType
psInt :: PSType
psInt = TypeInfo {
    _typePackage :: Text
_typePackage = Text
""
  , _typeModule :: Text
_typeModule = Text
"Prim"
  , _typeName :: Text
_typeName = Text
"Int"
  , _typeParameters :: [PSType]
_typeParameters = []
  }

psNumber :: PSType
psNumber :: PSType
psNumber = TypeInfo {
    _typePackage :: Text
_typePackage = Text
""
  , _typeModule :: Text
_typeModule = Text
"Prim"
  , _typeName :: Text
_typeName = Text
"Number"
  , _typeParameters :: [PSType]
_typeParameters = []
  }

-- | Uses  type parameters from 'haskType' (bridged).
psMaybe :: MonadReader BridgeData m => m PSType
psMaybe :: forall (m :: * -> *). MonadReader BridgeData m => m PSType
psMaybe = forall (lang :: Language).
Text -> Text -> Text -> [TypeInfo lang] -> TypeInfo lang
TypeInfo Text
"purescript-maybe" Text
"Data.Maybe" Text
"Maybe" forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadReader BridgeData m => m [PSType]
psTypeParameters

psString :: PSType
psString :: PSType
psString = TypeInfo {
    _typePackage :: Text
_typePackage = Text
""
  , _typeModule :: Text
_typeModule = Text
"Prim"
  , _typeName :: Text
_typeName = Text
"String"
  , _typeParameters :: [PSType]
_typeParameters = []
  }

-- | Uses  type parameters from 'haskType' (bridged).
psTuple :: MonadReader BridgeData m => m PSType
psTuple :: forall (m :: * -> *). MonadReader BridgeData m => m PSType
psTuple = do
  Int
size <- forall s (m :: * -> *) r a.
MonadReader s m =>
LensLike' (Const r) s a -> (a -> r) -> m r
views (forall t. HasHaskType t => Lens' t (TypeInfo 'Haskell)
haskType forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (lang1 :: Language) (lang2 :: Language).
Lens
  (TypeInfo lang1) (TypeInfo lang2) [TypeInfo lang1] [TypeInfo lang2]
typeParameters) forall (t :: * -> *) a. Foldable t => t a -> Int
length
  let
    tupleModule :: Text
tupleModule = if Int
size forall a. Eq a => a -> a -> Bool
== Int
2 then Text
"Data.Tuple" else Text
"Data.Tuple.Nested"
    tupleName :: Text
tupleName = Text
"Tuple" forall a. Semigroup a => a -> a -> a
<> if Int
size forall a. Eq a => a -> a -> Bool
== Int
2 then Text
"" else String -> Text
T.pack (forall a. Show a => a -> String
show Int
size)
  forall (lang :: Language).
Text -> Text -> Text -> [TypeInfo lang] -> TypeInfo lang
TypeInfo Text
"purescript-tuples" Text
tupleModule Text
tupleName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *). MonadReader BridgeData m => m [PSType]
psTypeParameters

psUnit :: PSType
psUnit :: PSType
psUnit = TypeInfo  {
    _typePackage :: Text
_typePackage = Text
"purescript-prelude"
  , _typeModule :: Text
_typeModule = Text
"Prelude"
  , _typeName :: Text
_typeName = Text
"Unit"
  , _typeParameters :: [PSType]
_typeParameters = []
  }

psWord :: PSType
psWord :: PSType
psWord = TypeInfo  {
    _typePackage :: Text
_typePackage = Text
"purescript-word"
  , _typeModule :: Text
_typeModule = Text
"Data.Word"
  , _typeName :: Text
_typeName = Text
"Word"
  , _typeParameters :: [PSType]
_typeParameters = []
  }

psWord8 :: PSType
psWord8 :: PSType
psWord8 = TypeInfo  {
    _typePackage :: Text
_typePackage = Text
"purescript-word"
  , _typeModule :: Text
_typeModule = Text
"Data.Word"
  , _typeName :: Text
_typeName = Text
"Word8"
  , _typeParameters :: [PSType]
_typeParameters = []
  }

psWord16 :: PSType
psWord16 :: PSType
psWord16 = TypeInfo  {
    _typePackage :: Text
_typePackage = Text
"purescript-word"
  , _typeModule :: Text
_typeModule = Text
"Data.Word"
  , _typeName :: Text
_typeName = Text
"Word16"
  , _typeParameters :: [PSType]
_typeParameters = []
  }

psWord32 :: PSType
psWord32 :: PSType
psWord32 = TypeInfo  {
    _typePackage :: Text
_typePackage = Text
"purescript-word"
  , _typeModule :: Text
_typeModule = Text
"Data.Word"
  , _typeName :: Text
_typeName = Text
"Word32"
  , _typeParameters :: [PSType]
_typeParameters = []
  }

psWord64 :: PSType
psWord64 :: PSType
psWord64 = TypeInfo  {
    _typePackage :: Text
_typePackage = Text
"purescript-word"
  , _typeModule :: Text
_typeModule = Text
"Data.Word"
  , _typeName :: Text
_typeName = Text
"Word64"
  , _typeParameters :: [PSType]
_typeParameters = []
  }