TypeExpression.hs

{-# LANGUAGE OverloadedStrings #-}
module Nirum.Constructs.TypeExpression (TypeExpression(..), toCode) where

import Data.String (IsString(fromString))

import qualified Data.Text as T

import Nirum.Constructs (Construct(toCode))
import Nirum.Constructs.Identifier (Identifier)

-- | Refers a type.
data TypeExpression
    = TypeIdentifier { identifier :: Identifier }
    | OptionModifier { type' :: TypeExpression }
    | SetModifier { elementType :: TypeExpression }
    | ListModifier { elementType :: TypeExpression }
    | MapModifier { keyType :: TypeExpression
                  , valueType :: TypeExpression
                  }
    deriving (Eq, Ord, Show)

instance Construct TypeExpression where
    toCode (TypeIdentifier id') = toCode id'
    toCode (OptionModifier type_) = toCode type_ `T.snoc` '?'
    toCode (SetModifier element) =
        '{' `T.cons` toCode element `T.snoc` '}'
    toCode (ListModifier element) =
        '[' `T.cons` toCode element `T.snoc` ']'
    toCode (MapModifier key value) =
        T.concat ["{", toCode key, ": ", toCode value, "}"]

instance IsString TypeExpression where
    fromString string = TypeIdentifier (fromString string :: Identifier)