{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ViewPatterns #-}
module Language.TCT.Token where

{-
import Data.Bool
import Data.Char (Char)
import Data.Eq (Eq(..))
import Data.Function (($), (.))
import Data.Foldable (foldMap, foldr)
import Data.Maybe (Maybe(..))
import Data.Semigroup (Semigroup(..))
import Data.Sequence (Seq)
import Data.Ord (Ord)
import Data.Text (Text)
import Data.Text.Buildable (Buildable(..))
import Data.Text.Lazy.Builder (Builder)
import Data.TreeSeq.Strict (Tree(..), Trees)
import GHC.Exts (IsList(..))
import Text.Show (Show(..))
import qualified Data.Char as Char
import qualified Data.Sequence as Seq
import qualified Data.Text as Text

import Language.TCT.Cell
import Language.TCT.Elem


instance Buildable Token where
	build (TokenPlain t)   = build t
	build (TokenTag t)     = "#"<>build t
	build (TokenLink lnk)  = build lnk
	build (TokenEscape c)  = "\\"<>build c
	build (TokenPair p ts) = build c<>buildTokens ts<>build o
		where (o,c) = pairBorders p ts

buildTokens :: Tokens -> Builder
buildTokens = foldr (\a -> (<> build (unCell a))) ""

instance Semigroup Tokens where
	Tokens (Seq.viewr -> xs:>TokenPlain x) <>
	 Tokens (Seq.viewl -> TokenPlain y:<ys) =
		Tokens (xs<>(TokenPlain (x<>y)<|ys))
	Tokens x <> Tokens y = Tokens (x<>y)
instance Monoid Tokens where
	mempty  = Tokens mempty
	mappend = (<>)
instance Buildable Tokens where
	build (Tokens ts) = foldr (\a -> (<> build a)) "" ts
instance IsList Tokens where
	type Item Tokens = Token
	fromList = Tokens . fromList
	toList (Tokens ts) = toList ts

unTokens :: Tokens -> Seq Token
unTokens (Tokens ts) = ts
-}