Language/LOL/Symantic/Repr/String.hs

   1 {-# LANGUAGE FlexibleInstances #-}
   2 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
   3 {-# LANGUAGE MultiParamTypeClasses #-}
   4 {-# LANGUAGE TypeFamilies #-}
   5 -- | Interpreter to serialize an expression into a 'String'.
   6 module Language.LOL.Symantic.Repr.String where
   7
   8 import Data.Monoid ((<>))
   9 import Data.String (IsString(..))
  10
  11 import Language.LOL.Symantic.Expr
  12
  13 -- * Type 'Repr_String'
  14
  15 -- | Interpreter's data.
  16 newtype Repr_String (lam:: * -> *) h
  17  =      Repr_String
  18  {    unRepr_String
  19         -- Inherited attributes:
  20         :: Precedence
  21         -> Repr_String_Lambda_Depth
  22         -- Synthetised attributes:
  23         -> String
  24  }
  25 type Repr_String_Lambda_Depth = Int
  26
  27 -- | Interpreter.
  28 string_from_expr :: Repr_String lam h -> String
  29 string_from_expr r = unRepr_String r precedence_Toplevel 0
  30
  31 instance Show (Repr_String lam a) where
  32         show = string_from_expr
  33 instance Sym_Lambda lam (Repr_String lam) where
  34         type Lambda_from_Repr (Repr_String lam) = lam
  35         app (Repr_String f) (Repr_String x) = Repr_String $ \p v ->
  36                 let p' = precedence_App in
  37                 paren p p' $
  38                 f p' v <> " " <> x p' v
  39         inline     = repr_string_fun "!"
  40         val        = repr_string_fun ""
  41         lazy       = repr_string_fun "~"
  42
  43         let_inline = repr_string_let "!"
  44         let_val    = repr_string_let ""
  45         let_lazy   = repr_string_let "~"
  46
  47 -- ** Helpers for 'Sym_Lambda' instances
  48 repr_string_fun :: String -> (Repr_String lam a2 -> Repr_String lam a1) -> Repr_String lam a
  49 repr_string_fun mode e =
  50         Repr_String $ \p v ->
  51                 let p' = precedence_Lambda in
  52                 let x = "x" <> show v in
  53                 paren p p' $
  54                 "\\" <> mode <> x <> " -> " <>
  55                 unRepr_String (e (Repr_String $ \_p _v -> x)) p' (succ v)
  56 repr_string_let
  57  :: String
  58  -> Repr_String lam a1
  59  -> (Repr_String lam a3 -> Repr_String lam a2)
  60  -> Repr_String lam a
  61 repr_string_let mode e in_ =
  62         Repr_String $ \p v ->
  63                 let p' = precedence_Let in
  64                 let x = "x" <> show v in
  65                 paren p p' $
  66                 "let" <> mode <> " " <> x <> " = " <> unRepr_String e p (succ v) <> " in " <>
  67                 unRepr_String (in_ (Repr_String $ \_p _v -> x)) p (succ v)
  68
  69 instance Sym_Bool (Repr_String lam) where
  70         bool a = Repr_String $ \_p _v ->
  71                 show a
  72         not (Repr_String x) =
  73                 Repr_String $ \p v ->
  74                         let p' = precedence_Not in
  75                         paren p p' $ "!" <> x (precedence_succ p') v
  76         and (Repr_String x) (Repr_String y) =
  77                 Repr_String $ \p v ->
  78                         let p' = precedence_And in
  79                         paren p p' $ x p' v <> " & " <> y p' v
  80         or (Repr_String x) (Repr_String y) =
  81                 Repr_String $ \p v ->
  82                         let p' = precedence_Or in
  83                         paren p p'  $ x p' v <> " | " <> y p' v
  84         {-xor (Repr_String x) (Repr_String y) =
  85                 Repr_String $ \p v ->
  86                         let p' = precedence_Xor in
  87                         paren p p'  $ x p' v <> " * " <> y p' v
  88         -}
  89 instance Sym_Int (Repr_String lam) where
  90         int a = Repr_String $ \_p _v ->
  91                 show a
  92         neg (Repr_String x) =
  93                 Repr_String $ \p v ->
  94                         let p' = precedence_Neg in
  95                         paren p p' $ "-" <> x (precedence_succ p') v
  96         add (Repr_String x) (Repr_String y) =
  97                 Repr_String $ \p v ->
  98                         let p' = precedence_Add in
  99                         paren p p' $ x p' v <> " + " <> y p' v
 100 instance Sym_Maybe lam (Repr_String lam) where
 101         maybe (Repr_String n) (Repr_String j) (Repr_String m) =
 102                 Repr_String $ \p v ->
 103                         let p' = precedence_Lambda in
 104                         paren p p' $ "maybe "
 105                                  <> n (precedence_succ p') v
 106                                  <> j (precedence_succ p') v
 107                                  <> m (precedence_succ p') v
 108 instance Sym_Maybe_Cons (Repr_String lam) where
 109         nothing =
 110                 Repr_String $ \_p _v ->
 111                         "nothing"
 112         just (Repr_String a) =
 113                 Repr_String $ \p v ->
 114                         let p' = precedence_Lambda in
 115                         paren p p' $ "just "
 116                                  <> a (precedence_succ p') v
 117 {-
 118 instance Sym_If Repr_String where
 119         if_
 120          (Repr_String cond)
 121          (Repr_String ok)
 122          (Repr_String ko) =
 123                 Repr_String $ \p v ->
 124                         let p' = precedence_If in
 125                         paren p p' $
 126                         "if " <> cond p' v <>
 127                         " then " <> ok p' v <>
 128                         " else " <> ko p' v
 129         when_ (Repr_String cond) (Repr_String ok) =
 130                 Repr_String $ \p v ->
 131                         let p' = precedence_If in
 132                         paren p p' $
 133                         "when " <> cond p' v <>
 134                         " " <> ok p' v
 135 -}
 136
 137 -- ** Type 'Precedence'
 138
 139 newtype Precedence = Precedence Int
 140  deriving (Eq, Ord, Show)
 141 precedence_pred :: Precedence -> Precedence
 142 precedence_pred (Precedence p) = Precedence (pred p)
 143 precedence_succ :: Precedence -> Precedence
 144 precedence_succ (Precedence p) = Precedence (succ p)
 145 paren :: (Monoid s, IsString s) => Precedence -> Precedence -> s -> s
 146 paren prec prec' x =
 147         if prec >= prec'
 148          then fromString "(" <> x <> fromString ")"
 149          else x
 150
 151 precedence_Toplevel :: Precedence
 152 precedence_Toplevel  = Precedence 0
 153 precedence_Lambda   :: Precedence
 154 precedence_Lambda    = Precedence 1
 155 precedence_Let      :: Precedence
 156 precedence_Let       = Precedence 2
 157 precedence_If       :: Precedence
 158 precedence_If        = Precedence 3
 159 precedence_Or       :: Precedence
 160 precedence_Or        = Precedence 4
 161 precedence_Add      :: Precedence
 162 precedence_Add       = precedence_Or
 163 precedence_Xor      :: Precedence
 164 precedence_Xor       = Precedence 5
 165 precedence_And      :: Precedence
 166 precedence_And       = Precedence 6
 167 precedence_App      :: Precedence
 168 precedence_App       = Precedence 7
 169 precedence_Not      :: Precedence
 170 precedence_Not       = Precedence 8
 171 precedence_Neg      :: Precedence
 172 precedence_Neg       = precedence_Not
 173 precedence_Atomic   :: Precedence
 174 precedence_Atomic    = Precedence 9