From 8c8f6155f1b05230c271059c52a503211aec872b Mon Sep 17 00:00:00 2001
From: Charles <sircharlesaze@gmail.com>
Date: Mon, 16 Mar 2020 14:15:42 +0100
Subject: file Renaming, basic REPL

---
 src/Assignment.hs        |  11 +++++
 src/Expr.hs              |  98 +++++++++++++++++++++++++++++++++++++++
 src/Polynomial.hs        |  87 +++++++++++++++++++++++++++++++++++
 src/Statement.hs         |  14 ++++++
 src/assignment.hs        |  11 -----
 src/atom.hs              |  49 --------------------
 src/expr.hs              |  43 -----------------
 src/main.hs              |  25 ++++++++++
 src/manifest             |  96 --------------------------------------
 src/parser/Assignment.hs |  15 ++++++
 src/parser/Core.hs       | 117 +++++++++++++++++++++++++++++++++++++++++++++++
 src/parser/Expr.hs       |  42 +++++++++++++++++
 src/parser/Statement.hs  |  12 +++++
 src/parser/assignment.hs |  15 ------
 src/parser/core.hs       | 116 ----------------------------------------------
 src/parser/expr.hs       |  45 ------------------
 src/parser/statement.hs  |  12 -----
 src/polynomial.hs        |  95 --------------------------------------
 src/statement.hs         |  14 ------
 19 files changed, 421 insertions(+), 496 deletions(-)
 create mode 100644 src/Assignment.hs
 create mode 100644 src/Expr.hs
 create mode 100644 src/Polynomial.hs
 create mode 100644 src/Statement.hs
 delete mode 100644 src/assignment.hs
 delete mode 100644 src/atom.hs
 delete mode 100644 src/expr.hs
 create mode 100644 src/main.hs
 delete mode 100644 src/manifest
 create mode 100644 src/parser/Assignment.hs
 create mode 100644 src/parser/Core.hs
 create mode 100644 src/parser/Expr.hs
 create mode 100644 src/parser/Statement.hs
 delete mode 100644 src/parser/assignment.hs
 delete mode 100644 src/parser/core.hs
 delete mode 100644 src/parser/expr.hs
 delete mode 100644 src/parser/statement.hs
 delete mode 100644 src/polynomial.hs
 delete mode 100644 src/statement.hs

(limited to 'src')

diff --git a/src/Assignment.hs b/src/Assignment.hs
new file mode 100644
index 0000000..c086280
--- /dev/null
+++ b/src/Assignment.hs
@@ -0,0 +1,11 @@
+module Assignment where
+
+import qualified Expr as E
+
+data Assignment
+    = Variable String E.Expr
+    | Function String String E.Expr
+
+instance Show Assignment where
+    show (Variable name e) = name ++ " = " ++ show e
+    show (Function name arg e) = name ++ "(" ++ arg ++ ") = " ++ show e
diff --git a/src/Expr.hs b/src/Expr.hs
new file mode 100644
index 0000000..e3d8aef
--- /dev/null
+++ b/src/Expr.hs
@@ -0,0 +1,98 @@
+module Expr where
+
+import Data.List
+
+
+data Atom
+    = Rational Float
+    | Imaginary Float
+    | Matrix [[Expr]]
+
+data Expr
+    = EAtom Atom
+    | Add Expr Expr
+    | Sub Expr Expr
+    | Mul Expr Expr
+    | Div Expr Expr
+    | Mod Expr Expr
+    | Exp Expr Expr
+    | Dot Expr Expr
+    | Variable String
+    | Function String Expr
+
+eval :: Expr -> Maybe Atom
+eval (EAtom a) = Just a
+eval (Add e1 e2) = evalInfix e1 e2 (+?)
+eval (Sub e1 e2) = evalInfix e1 e2 (-?)
+eval (Mul e1 e2) = evalInfix e1 e2 (*?)
+eval (Div e1 e2) = evalInfix e1 e2 (/?)
+eval (Mod e1 e2) = evalInfix e1 e2 (%?)
+eval (Exp e1 e2) = evalInfix e1 e2 (^?)
+eval (Dot e1 e2) = evalInfix e1 e2 (**?)
+eval _ = Nothing
+
+evalInfix :: Expr -> Expr -> (Atom -> Atom -> Maybe Atom) -> Maybe Atom
+evalInfix e1 e2 f = do a <- eval e1
+                       b <- eval e2
+                       f a b
+
+infixl 6 +?
+(+?) :: Atom -> Atom -> Maybe Atom
+(Rational a) +? (Rational b) = Just $ Rational (a + b)
+(Imaginary a) +? (Imaginary b) = Just $ Imaginary (a + b)
+_ +? _ = Nothing
+
+infixl 6 -?
+(-?) :: Atom -> Atom -> Maybe Atom
+(Rational a) -? (Rational b) = Just $ Rational (a - b)
+(Imaginary a) -? (Imaginary b) = Just $ Imaginary (a - b)
+_ -? _ = Nothing
+
+infixl 7 *?
+(*?) :: Atom -> Atom -> Maybe Atom
+(Rational a) *? (Rational b) = Just $ Rational (a * b)
+(Rational a) *? (Imaginary b) = Just $ Imaginary (a * b)
+(Imaginary a) *? (Imaginary b) = (Imaginary (a * b)) ^? Rational 2
+_ *? _ = Nothing
+
+infixl 7 /?
+(/?) :: Atom -> Atom -> Maybe Atom
+_ /? (Rational 0) = Nothing
+(Rational a) /? (Rational b) = Just $ Rational (a / b)
+_ /? _ = Nothing
+
+infixl 7 %?
+(%?) :: Atom -> Atom -> Maybe Atom
+_ %? _ = Nothing
+
+infixr 8 ^?
+(^?) :: Atom -> Atom -> Maybe Atom
+(Rational a) ^? (Rational b) = Just $ Rational (a ** b)
+(Imaginary a) ^? (Rational 0) = Just $ Rational a
+(Imaginary a) ^? (Rational 1) = Just $ Imaginary a
+(Imaginary a) ^? (Rational 2) = Just $ Rational (-a)
+(Imaginary a) ^? (Rational 3) = Just $ Imaginary (-a)
+(Imaginary a) ^? (Rational b) = Imaginary a ^? (Rational (b - 4))
+_ ^? _ = Nothing
+
+infixr 8 **?
+(**?) :: Atom -> Atom -> Maybe Atom
+_ **? _ = Nothing
+
+instance Show Expr where
+    show (EAtom a) = show a
+    show (Add e1 e2) = show e1 ++ " + " ++ show e2
+    show (Sub e1 e2) = show e1 ++ " - " ++ show e2
+    show (Mul e1 e2) = show e1 ++ " * " ++ show e2
+    show (Div e1 e2) = show e1 ++ " / " ++ show e2
+    show (Mod e1 e2) = show e1 ++ " % " ++ show e2
+    show (Exp e1 e2) = show e1 ++ " ^ " ++ show e2
+    show (Dot e1 e2) = show e1 ++ " ** " ++ show e2
+    show (Variable name) = name
+    show (Function name e) = name ++ "(" ++ show e ++ ")"
+
+instance Show Atom where
+    show (Rational r) = show r
+    show (Imaginary i) = show i ++ "i"
+    show (Matrix m) = intercalate "\n" (map showRow m)
+        where showRow r = "[ " ++ intercalate ", " (map show r) ++ " ]"
diff --git a/src/Polynomial.hs b/src/Polynomial.hs
new file mode 100644
index 0000000..cd0da4f
--- /dev/null
+++ b/src/Polynomial.hs
@@ -0,0 +1,87 @@
+module Polynomial where
+
+-- import Data.List
+--
+--
+-- data Equation = Equation { left :: Polynomial, right :: Polynomial }
+-- type Polynomial = [Term]
+-- data Term = Term { coefficient :: Float, exponent :: Int }
+--
+-- instance Eq Term where
+--     (Term _ e1) == (Term _ e2) = e1 == e2
+--
+-- instance Ord Term where
+--     compare (Term _ e1) (Term _ e2) = compare e1 e2
+--
+-- instance Show Term where
+--     show (Term 0 e) = ""
+--     show (Term c 0) = show (round c)
+--     show (Term c e) = show (round c) ++ " * X^" ++ show e
+--
+-- instance Show Equation where
+--     show (Equation l r) = showPolynomial (filterNull l)
+--                           ++ " = "
+--                           ++ showPolynomial (filterNull r)
+--         where showPolynomial [] = "0"
+--               showPolynomial p  = dropWhile (`elem` " +") $ foldl f "" (map show p)
+--                 where f s "" = s
+--                       f s (c:cs)
+--                         | c == '-'  = s ++ " - " ++ cs
+--                         | otherwise = s ++ " + " ++ (c:cs)
+--
+--
+-- filterNull :: Polynomial -> Polynomial
+-- filterNull = filter (\t -> coefficient t /= 0)
+--
+-- equationMap :: (Polynomial -> Polynomial) -> Equation -> Equation
+-- equationMap f (Equation l r) = Equation (f l) (f r)
+--
+-- degree :: Polynomial -> Int
+-- degree [] = 0
+-- degree p  = Equation.exponent (maximum p)
+--
+-- reduce :: Equation -> Equation
+-- reduce equ = Equation (merge (left stdForm) (right stdForm)) []
+--     where stdForm = equationMap (\a -> (reducePolynomial $ sort a)) equ
+--           merge [] rs = rs
+--           merge ls [] = ls
+--           merge (l:ls) (r:rs)
+--             | l == r = (subTerm l r) : merge ls rs
+--             | l < r  = l : merge ls (r:rs)
+--             | r < l  = r : merge (l:ls) rs
+--             where subTerm (Term c1 e) (Term c2 _) = Term (c1 - c2) e
+--           reducePolynomial []         = []
+--           reducePolynomial [t]        = [t]
+--           reducePolynomial (t1:t2:ts)
+--             | t1 == t2  = (addTerm t1 t2) : reducePolynomial ts
+--             | otherwise = t1 : reducePolynomial (t2:ts)
+--             where addTerm (Term c1 e) (Term c2 _) = Term (c1 + c2) e
+--
+-- solveDegree2 :: Float -> Float -> Float -> [Float]
+-- solveDegree2 a b c
+--     | phi < 0   = []
+--     | phi == 0  = [(-b) / (2.0 * a)]
+--     | phi > 0   = [ (-b + mySqrt phi) / (2.0 * a) -- not alowed
+--                   , (-b - mySqrt phi) / (2.0 * a)
+--                   ]
+--     where phi = b * b - 4.0 * a * c
+--
+-- solveDegree1 :: Float -> Float -> Float
+-- solveDegree1 b c = -c / b
+--
+-- solve :: Polynomial -> [Float]
+-- solve [t0]         = []
+-- solve [t0, t1]     = [solveDegree1 (coefficient t1) (coefficient t0)]
+-- solve [t0, t1, t2] = solveDegree2 (coefficient t2) (coefficient t1) (coefficient t0)
+-- solve _            = undefined
+--
+-- mySqrt :: Float -> Float
+-- mySqrt n
+--   | n < 0     = undefined
+--   | otherwise = mySqrt' (n / 2)
+--     where mySqrt' x = if abs (x * x - n) < 0.01
+--                          then x
+--                          else mySqrt' xn
+--             where xn = b - (a * a) / (2 * b)
+--                     where a = (n - x * x) / (2 * x)
+--                           b = x + a
diff --git a/src/Statement.hs b/src/Statement.hs
new file mode 100644
index 0000000..75dfdb4
--- /dev/null
+++ b/src/Statement.hs
@@ -0,0 +1,14 @@
+module Statement where
+
+import Assignment
+import Expr
+
+
+data Statement
+    = SAssignment Assignment
+    | SExpr Expr
+
+instance Show Statement where
+    show (SAssignment a) = show a
+    show (SExpr e) = show e
+
diff --git a/src/assignment.hs b/src/assignment.hs
deleted file mode 100644
index c086280..0000000
--- a/src/assignment.hs
+++ /dev/null
@@ -1,11 +0,0 @@
-module Assignment where
-
-import qualified Expr as E
-
-data Assignment
-    = Variable String E.Expr
-    | Function String String E.Expr
-
-instance Show Assignment where
-    show (Variable name e) = name ++ " = " ++ show e
-    show (Function name arg e) = name ++ "(" ++ arg ++ ") = " ++ show e
diff --git a/src/atom.hs b/src/atom.hs
deleted file mode 100644
index 5f1b42c..0000000
--- a/src/atom.hs
+++ /dev/null
@@ -1,49 +0,0 @@
-module Atom where
-
-
-data Atom
-    = ARational Float
-    | AImaginary Float
-
-infixl 6 +?
-(+?) :: Atom -> Atom -> Maybe Atom
-(ARational a) +? (ARational b) = Just $ ARational (a + b)
-(AImaginary a) +? (AImaginary b) = Just $ AImaginary (a + b)
-_ +? _ = Nothing
-
-infixl 6 -?
-(-?) :: Atom -> Atom -> Maybe Atom
-(ARational a) -? (ARational b) = Just $ ARational (a - b)
-(AImaginary a) -? (AImaginary b) = Just $ AImaginary (a - b)
-_ -? _ = Nothing
-
-infixl 7 *?
-(*?) :: Atom -> Atom -> Maybe Atom
-(ARational a) *? (ARational b) = Just $ ARational (a * b)
-(ARational a) *? (AImaginary b) = Just $ AImaginary (a * b)
-(AImaginary a) *? (AImaginary b) = (AImaginary (a * b)) ^? ARational 2
-_ *? _ = Nothing
-
-infixl 7 /?
-(/?) :: Atom -> Atom -> Maybe Atom
-_ /? (ARational 0) = Nothing
-(ARational a) /? (ARational b) = Just $ ARational (a / b)
-_ /? _ = Nothing
-
-infixl 7 %?
-(%?) :: Atom -> Atom -> Maybe Atom
-_ %? _ = Nothing
-
-infixr 8 ^?
-(^?) :: Atom -> Atom -> Maybe Atom
-(ARational a) ^? (ARational b) = Just $ ARational (a ** b)
-(AImaginary a) ^? (ARational 0) = Just $ ARational a
-(AImaginary a) ^? (ARational 1) = Just $ AImaginary a
-(AImaginary a) ^? (ARational 2) = Just $ ARational (-a)
-(AImaginary a) ^? (ARational 3) = Just $ AImaginary (-a)
-(AImaginary a) ^? (ARational b) = AImaginary a ^? (ARational (b - 4))
-_ ^? _ = Nothing
-
-instance Show Atom where
-    show (ARational r) = show r
-    show (AImaginary i) = show i ++ "i"
diff --git a/src/expr.hs b/src/expr.hs
deleted file mode 100644
index e6f1f25..0000000
--- a/src/expr.hs
+++ /dev/null
@@ -1,43 +0,0 @@
-module Expr where
-
-import Atom
-
-
-data Expr
-    = EAtom Atom
-    | Add Expr Expr
-    | Sub Expr Expr
-    | Mul Expr Expr
-    | Div Expr Expr
-    | Mod Expr Expr
-    | Exp Expr Expr
-    | Variable String
-    | Function String Expr
-
-
-
-eval :: Expr -> Maybe Atom
-eval (EAtom a) = Just a
-eval (Add e1 e2) = evalInfix e1 e2 (+?)
-eval (Sub e1 e2) = evalInfix e1 e2 (-?)
-eval (Mul e1 e2) = evalInfix e1 e2 (*?)
-eval (Div e1 e2) = evalInfix e1 e2 (/?)
-eval (Mod e1 e2) = evalInfix e1 e2 (%?)
-eval (Exp e1 e2) = evalInfix e1 e2 (^?)
-eval _ = Nothing
-
-evalInfix :: Expr -> Expr -> (Atom -> Atom -> Maybe Atom) -> Maybe Atom
-evalInfix e1 e2 f = do a <- eval e1
-                       b <- eval e2
-                       f a b
-
-instance Show Expr where
-    show (EAtom a) = show a
-    show (Add e1 e2) = show e1 ++ " + " ++ show e2
-    show (Sub e1 e2) = show e1 ++ " - " ++ show e2
-    show (Mul e1 e2) = show e1 ++ " * " ++ show e2
-    show (Div e1 e2) = show e1 ++ " / " ++ show e2
-    show (Mod e1 e2) = show e1 ++ " % " ++ show e2
-    show (Exp e1 e2) = show e1 ++ " ^ " ++ show e2
-    show (Variable name) = name
-    show (Function name e) = name ++ "(" ++ show e ++ ")"
diff --git a/src/main.hs b/src/main.hs
new file mode 100644
index 0000000..34a190a
--- /dev/null
+++ b/src/main.hs
@@ -0,0 +1,25 @@
+import System.IO
+import Statement
+import Parser.Statement
+import Parser.Core
+
+
+main = do
+    line <- prompt
+    loop line
+
+loop :: String -> IO ()
+loop "exit" = return ()
+loop line   = do s <- parseIO line
+                 putStrLn $ show s
+                 main
+
+prompt :: IO String
+prompt = do putStr "> "
+            hFlush stdout
+            getLine
+
+parseIO :: String -> IO Statement
+parseIO input = case parseStrict statementP input of
+                  Nothing -> fail "Couldn't parse input"
+                  Just s  -> return s
diff --git a/src/manifest b/src/manifest
deleted file mode 100644
index 7216fa7..0000000
--- a/src/manifest
+++ /dev/null
@@ -1,96 +0,0 @@
-Data struct:
-    - expression
-        - matrix
-        - complex
-
-        - polynomial
-
-State Data struct:
-    - function
-    - variable
-
-
-
-Instruction/line:
-    if is '?' evaluate label else declare label.
-
-instruction  ::= <label> '=' (<expr> | '?')
-
-
-Declaration:
-    label is a declaration of function or variable name
-
-label        ::= <funcDecl> | <var>
-funcDecl     ::= <var> '(' <var> ')'
-var          ::= [a-zA-Z]+
-
-
-Expression:
-
-5. real imag matrix
-4. + -
-3. * / % **
-2. ^
-1. ( )    -- not an operator
-
-expr         ::= <sum> | <imag> | <matrix> | <real> | <var> | <funcExpr>
-
-Arithmetic:
-
-sum          ::= <term>   (+ | -)           <sum>    | <term>
-term         ::= <factor> (* | / | % | **)? <term>   | <factor>  -- default to '*'
-factor       ::= <base>   '^'               <factor> | <base>
-base         ::= '(' <expr> ')'                      | <expr>
-
-Leaf:
-
-real         ::= [0-9]+(\.[0-9]+)?
-imag         ::= <real> '*'? 'i'
-matrix       ::= '[' (<matrixRow> ';')* ']'
-matrixRow    ::= '[' (<expr> ',')* ']'
-fundExpr     ::= <var> '(' <expr> ')'
-
-REPL:
-
-1. read user input
-2. parse it into an ast
-3. reduce the ast to the minimum possible form
-4.
-
-every expression is a binary tree, except () which can be interpreted by changing the
-structure of the tree.
-
-operators and operand are both expression (tree nodes).
-
-operators always need 2 operand  (not leaf node)
-operand need 0                   (leaf node)
-
-evaluation of operand return the operand
-evaluation of operator, evaluate his childs, perform the operation on them, return the result
-
-fold?
-!monoid
-
-    +
-   / \
-  *   \
- / \   \      3 * 4 + (5 - 3i)
-3   4   -
-       / \
-      5   3i
-
-Node +
-|_ Node *
-|  |_ Leaf 3
-|  |_ Leaf 4
-|
-|_ Node -
-   |_ Leaf 5
-   |_ Leaf 3i
-
-
-i^0 = 1
-i^1 = sqrt(-1) = i
-i^2 = -1
-i^3 = -sqrt(-1) = -i
-i^4 = 1
diff --git a/src/parser/Assignment.hs b/src/parser/Assignment.hs
new file mode 100644
index 0000000..bb782f5
--- /dev/null
+++ b/src/parser/Assignment.hs
@@ -0,0 +1,15 @@
+module Parser.Assignment where
+
+import Control.Applicative
+import Parser.Core
+import qualified Parser.Expr as E
+import Assignment
+
+variableP :: Parser Assignment
+variableP = Variable <$> alphaStringP <* char '=' <*> E.exprP
+
+functionP :: Parser Assignment
+functionP = Function <$> alphaStringP <*> parenthesize alphaStringP <* char '=' <*> E.exprP
+
+assignmentP :: Parser Assignment
+assignmentP = variableP <|> functionP
diff --git a/src/parser/Core.hs b/src/parser/Core.hs
new file mode 100644
index 0000000..b22bcf4
--- /dev/null
+++ b/src/parser/Core.hs
@@ -0,0 +1,117 @@
+module Parser.Core where
+
+import Control.Applicative
+import Control.Monad
+import Data.Char
+
+newtype Parser a = Parser { parse :: String -> Maybe (a, String) }
+
+parseStrict :: Parser a -> String -> Maybe a
+parseStrict p input = case parse p input of Just (a, "") -> Just a
+                                            _            -> Nothing
+
+instance Functor Parser where
+    -- fmap :: (a -> b) -> Parser a -> Parser b
+    fmap f (Parser p) = Parser new_p
+        where new_p s = do
+                (x, s') <- p s
+                return (f x, s')
+
+instance Applicative Parser where
+    -- pure :: a -> Parser a
+    pure x = Parser (\s -> Just (x, s))
+    -- (<*>) :: Parser (a -> b) -> Parser a -> Parser b
+    (Parser p1) <*> (Parser p2) = Parser new_p
+        where new_p s = do
+                (f, s') <- p1 s
+                (x, s'') <- p2 s'
+                return (f x, s'')
+
+instance Alternative Parser where
+    -- empty :: Parser a
+    empty = Parser (\_ -> Nothing)
+    -- (<|>) :: Parser a -> Parser a -> Parser a
+    (Parser p1) <|> (Parser p2) = Parser new_p
+        where new_p s = p1 s <|> p2 s
+
+instance Monad Parser where
+    -- return :: a -> Parser a
+    return x = pure x
+    -- (>>=) :: Parser a -> (a -> Parser b) -> Parser b
+    (Parser p1) >>= f = Parser new_p
+        where new_p s = do
+                (x, s') <- p1 s
+                parse (f x) s'
+
+
+satisfyChar :: (Char -> Bool) -> Parser Char
+satisfyChar f = Parser p
+    where p []     = Nothing
+          p (c:cs) = if f c then Just (c, cs)
+                            else Nothing
+
+sepBy :: Parser b -> Parser a -> Parser [a]
+sepBy sep x = (:) <$> x <*> (many (sep *> x))
+
+-- sepByMap :: (b -> a -> a) -> Parser b -> Parser a -> Parser [a]
+-- sepByMap f sep x = (:) <$> x <*> (many (f <$> sep <*> x))
+
+chainl :: Parser a -> Parser (a -> a -> a) -> a -> Parser a
+chainl p op a = chainl1 p op <|> pure a
+
+chainl1 :: Parser a -> Parser (a -> a -> a) -> Parser a
+chainl1 p op = p >>= rest
+    where rest prev = do f <- op
+                         e <- p
+                         rest (f prev e)
+                      <|> return prev
+
+signed :: Num a => Parser a -> Parser a
+signed p = do char '-'
+              x <- p
+              return (-x)
+           <|> p
+
+readParser :: Read a => Parser String -> Parser a
+readParser p = read <$> p
+
+infixOp :: String -> (a -> a -> a) -> Parser (a -> a -> a)
+infixOp opStr f = string opStr *> pure f
+
+parenthesize :: Parser a -> Parser a
+parenthesize p = char '(' *> p <* char ')'
+
+char :: Char -> Parser Char
+char c = satisfyChar (c ==)
+
+string :: String -> Parser String
+string s = sequenceA $ char <$> s
+
+alphaP :: Parser Char
+alphaP = satisfyChar isAlpha
+
+alphaStringP :: Parser String
+alphaStringP = some alphaP
+
+digitsP :: Parser String
+digitsP = some (satisfyChar isDigit) -- at least one digit to avoid read exception
+
+spacesP :: Parser String
+spacesP = many (satisfyChar isSpace)
+
+unsignedIntP :: Parser Int
+unsignedIntP = readParser digitsP
+
+intP :: Parser Int
+intP = signed unsignedIntP
+
+unsignedFloatP :: Parser Float
+unsignedFloatP = readParser p
+    where p = do pos <- digitsP
+                 char '.'
+                 dec <- digitsP
+                 return (pos ++ "." ++ dec)
+              <|> digitsP
+
+floatP :: Parser Float
+floatP = signed unsignedFloatP
diff --git a/src/parser/Expr.hs b/src/parser/Expr.hs
new file mode 100644
index 0000000..5ba4be7
--- /dev/null
+++ b/src/parser/Expr.hs
@@ -0,0 +1,42 @@
+module Parser.Expr where
+
+import Control.Applicative
+
+import Parser.Core
+import Expr
+
+
+imaginaryP :: Parser Atom
+imaginaryP = Imaginary <$> (floatP <* char 'i')
+
+rationalP :: Parser Atom
+rationalP = Rational <$> floatP
+
+matrixP :: Parser Atom
+matrixP = Matrix <$> (char '[' *> sepBy (char ';') matrixRowP <* char ']')
+    where matrixRowP = char '[' *> sepBy (char ',') exprP <* char ']'
+
+exprP :: Parser Expr
+exprP = termP `chainl1` termOpP
+    where termOpP = infixOp "+" Add <|> infixOp "-" Sub
+
+termP :: Parser Expr
+termP =  factorP `chainl1` factorOpP
+    where factorOpP = infixOp "**" Dot <|> infixOp "*" Mul <|> infixOp "/" Div <|> infixOp "%" Mod
+
+factorP :: Parser Expr
+factorP =  endpointP `chainl1` expOpP
+    where expOpP = infixOp "^" Exp
+          endpointP = parenthesisExprP <|> (EAtom <$> atomP) <|> functionP <|> variableP
+
+variableP :: Parser Expr
+variableP = Variable <$> alphaStringP
+
+functionP :: Parser Expr
+functionP = Function <$> alphaStringP <*> parenthesisExprP
+
+parenthesisExprP :: Parser Expr
+parenthesisExprP = parenthesize exprP
+
+atomP :: Parser Atom
+atomP = imaginaryP <|> rationalP <|> matrixP
diff --git a/src/parser/Statement.hs b/src/parser/Statement.hs
new file mode 100644
index 0000000..74f7f01
--- /dev/null
+++ b/src/parser/Statement.hs
@@ -0,0 +1,12 @@
+module Parser.Statement where
+
+import Control.Applicative
+import Parser.Core
+import Parser.Expr
+import Parser.Assignment
+import Statement
+
+
+statementP :: Parser Statement
+statementP = SAssignment <$> assignmentP
+             <|> SExpr <$> exprP <* char '=' <* char '?'
diff --git a/src/parser/assignment.hs b/src/parser/assignment.hs
deleted file mode 100644
index bb782f5..0000000
--- a/src/parser/assignment.hs
+++ /dev/null
@@ -1,15 +0,0 @@
-module Parser.Assignment where
-
-import Control.Applicative
-import Parser.Core
-import qualified Parser.Expr as E
-import Assignment
-
-variableP :: Parser Assignment
-variableP = Variable <$> alphaStringP <* char '=' <*> E.exprP
-
-functionP :: Parser Assignment
-functionP = Function <$> alphaStringP <*> parenthesize alphaStringP <* char '=' <*> E.exprP
-
-assignmentP :: Parser Assignment
-assignmentP = variableP <|> functionP
diff --git a/src/parser/core.hs b/src/parser/core.hs
deleted file mode 100644
index b622634..0000000
--- a/src/parser/core.hs
+++ /dev/null
@@ -1,116 +0,0 @@
-module Parser.Core where
-
-import Control.Applicative
-import Control.Monad
-import Data.Char
-
-newtype Parser a = Parser { parse :: String -> Maybe (a, String) }
-
-parseStrict :: Parser a -> String -> Maybe a
-parseStrict p input = case parse p input of Just (a, "") -> Just a
-                                            _            -> Nothing
-
-instance Functor Parser where
-    -- fmap :: (a -> b) -> Parser a -> Parser b
-    fmap f (Parser p) = Parser new_p
-        where new_p s = do
-                (x, s') <- p s
-                return (f x, s')
-
-instance Applicative Parser where
-    -- pure :: a -> Parser a
-    pure x = Parser (\s -> Just (x, s))
-    -- (<*>) :: Parser (a -> b) -> Parser a -> Parser b
-    (Parser p1) <*> (Parser p2) = Parser new_p
-        where new_p s = do
-                (f, s') <- p1 s
-                (x, s'') <- p2 s'
-                return (f x, s'')
-
-instance Alternative Parser where
-    -- empty :: Parser a
-    empty = Parser (\_ -> Nothing)
-    -- (<|>) :: Parser a -> Parser a -> Parser a
-    (Parser p1) <|> (Parser p2) = Parser new_p
-        where new_p s = p1 s <|> p2 s
-
-instance Monad Parser where
-    -- return :: a -> Parser a
-    return x = pure x
-    -- (>>=) :: Parser a -> (a -> Parser b) -> Parser b
-    (Parser p1) >>= f = Parser new_p
-        where new_p s = do
-                (x, s') <- p1 s
-                parse (f x) s'
-
-
-satisfyChar :: (Char -> Bool) -> Parser Char
-satisfyChar f = Parser p
-    where p []     = Nothing
-          p (c:cs) = if f c then Just (c, cs)
-                            else Nothing
-
--- sepBy :: Parser b -> Parser a -> Parser [a]
--- sepBy sep x = (:) <$> x <*> (many (sep *> x))
--- sepByMap :: (b -> a -> a) -> Parser b -> Parser a -> Parser [a]
--- sepByMap f sep x = (:) <$> x <*> (many (f <$> sep <*> x))
-
-chainl :: Parser a -> Parser (a -> a -> a) -> a -> Parser a
-chainl p op a = chainl1 p op <|> pure a
-
-chainl1 :: Parser a -> Parser (a -> a -> a) -> Parser a
-chainl1 p op = p >>= rest
-    where rest prev = do f <- op
-                         e <- p
-                         rest (f prev e)
-                      <|> return prev
-
-signed :: Num a => Parser a -> Parser a
-signed p = do char '-'
-              x <- p
-              return (-x)
-           <|> p
-
-readParser :: Read a => Parser String -> Parser a
-readParser p = read <$> p
-
-infixOp :: String -> (a -> a -> a) -> Parser (a -> a -> a)
-infixOp opStr f = string opStr *> pure f
-
-parenthesize :: Parser a -> Parser a
-parenthesize p = char '(' *> p <* char ')'
-
-char :: Char -> Parser Char
-char c = satisfyChar (c ==)
-
-string :: String -> Parser String
-string s = sequenceA $ char <$> s
-
-alphaP :: Parser Char
-alphaP = satisfyChar isAlpha
-
-alphaStringP :: Parser String
-alphaStringP = some alphaP
-
-digitsP :: Parser String
-digitsP = some (satisfyChar isDigit) -- at least one digit to avoid read exception
-
-spacesP :: Parser String
-spacesP = many (satisfyChar isSpace)
-
-unsignedIntP :: Parser Int
-unsignedIntP = readParser digitsP
-
-intP :: Parser Int
-intP = signed unsignedIntP
-
-unsignedFloatP :: Parser Float
-unsignedFloatP = readParser p
-    where p = do pos <- digitsP
-                 char '.'
-                 dec <- digitsP
-                 return (pos ++ "." ++ dec)
-              <|> digitsP
-
-floatP :: Parser Float
-floatP = signed unsignedFloatP
diff --git a/src/parser/expr.hs b/src/parser/expr.hs
deleted file mode 100644
index b84362d..0000000
--- a/src/parser/expr.hs
+++ /dev/null
@@ -1,45 +0,0 @@
-module Parser.Expr where
-
-import Control.Applicative
-
-import Parser.Core
-import Atom
-import Expr
-
-
-imaginaryP :: Parser Atom
-imaginaryP = AImaginary <$> (floatP <* char 'i')
-
-rationalP :: Parser Atom
-rationalP = ARational <$> floatP
-
-termOpP :: Parser (Expr -> Expr -> Expr)
-termOpP = infixOp "+" Add <|> infixOp "-" Sub
-
-factorOpP :: Parser (Expr -> Expr -> Expr)
-factorOpP = infixOp "*" Mul <|> infixOp "/" Div <|> infixOp "%" Mod
-
-expOpP :: Parser (Expr -> Expr -> Expr)
-expOpP = infixOp "^" Exp
-
-exprP :: Parser Expr
-exprP = termP `chainl1` termOpP
-
-termP :: Parser Expr
-termP =  factorP `chainl1` factorOpP
-
-variableP :: Parser Expr
-variableP = Variable <$> alphaStringP
-
-functionP :: Parser Expr
-functionP = Function <$> alphaStringP <*> parenthesisExprP
-
-factorP :: Parser Expr
-factorP =  endpointP `chainl1` expOpP
-    where endpointP = parenthesisExprP <|> (EAtom <$> atomP) <|> functionP <|> variableP
-
-parenthesisExprP :: Parser Expr
-parenthesisExprP = parenthesize exprP
-
-atomP :: Parser Atom
-atomP = imaginaryP <|> rationalP
diff --git a/src/parser/statement.hs b/src/parser/statement.hs
deleted file mode 100644
index 74f7f01..0000000
--- a/src/parser/statement.hs
+++ /dev/null
@@ -1,12 +0,0 @@
-module Parser.Statement where
-
-import Control.Applicative
-import Parser.Core
-import Parser.Expr
-import Parser.Assignment
-import Statement
-
-
-statementP :: Parser Statement
-statementP = SAssignment <$> assignmentP
-             <|> SExpr <$> exprP <* char '=' <* char '?'
diff --git a/src/polynomial.hs b/src/polynomial.hs
deleted file mode 100644
index f332131..0000000
--- a/src/polynomial.hs
+++ /dev/null
@@ -1,95 +0,0 @@
-module Equation
-( Equation (..)
-, Polynomial
-, Term (..)
-, degree
-, reduce
-, solve
-, filterNull
-) where
-
-import Data.List
-
-
-data Equation = Equation { left :: Polynomial, right :: Polynomial }
-type Polynomial = [Term]
-data Term = Term { coefficient :: Float, exponent :: Int }
-
-instance Eq Term where
-    (Term _ e1) == (Term _ e2) = e1 == e2
-
-instance Ord Term where
-    compare (Term _ e1) (Term _ e2) = compare e1 e2
-
-instance Show Term where
-    show (Term 0 e) = ""
-    show (Term c 0) = show (round c)
-    show (Term c e) = show (round c) ++ " * X^" ++ show e
-
-instance Show Equation where
-    show (Equation l r) = showPolynomial (filterNull l)
-                          ++ " = "
-                          ++ showPolynomial (filterNull r)
-        where showPolynomial [] = "0"
-              showPolynomial p  = dropWhile (`elem` " +") $ foldl f "" (map show p)
-                where f s "" = s
-                      f s (c:cs)
-                        | c == '-'  = s ++ " - " ++ cs
-                        | otherwise = s ++ " + " ++ (c:cs)
-
-
-filterNull :: Polynomial -> Polynomial
-filterNull = filter (\t -> coefficient t /= 0)
-
-equationMap :: (Polynomial -> Polynomial) -> Equation -> Equation
-equationMap f (Equation l r) = Equation (f l) (f r)
-
-degree :: Polynomial -> Int
-degree [] = 0
-degree p  = Equation.exponent (maximum p)
-
-reduce :: Equation -> Equation
-reduce equ = Equation (merge (left stdForm) (right stdForm)) []
-    where stdForm = equationMap (\a -> (reducePolynomial $ sort a)) equ
-          merge [] rs = rs
-          merge ls [] = ls
-          merge (l:ls) (r:rs)
-            | l == r = (subTerm l r) : merge ls rs
-            | l < r  = l : merge ls (r:rs)
-            | r < l  = r : merge (l:ls) rs
-            where subTerm (Term c1 e) (Term c2 _) = Term (c1 - c2) e
-          reducePolynomial []         = []
-          reducePolynomial [t]        = [t]
-          reducePolynomial (t1:t2:ts)
-            | t1 == t2  = (addTerm t1 t2) : reducePolynomial ts
-            | otherwise = t1 : reducePolynomial (t2:ts)
-            where addTerm (Term c1 e) (Term c2 _) = Term (c1 + c2) e
-
-solveDegree2 :: Float -> Float -> Float -> [Float]
-solveDegree2 a b c
-    | phi < 0   = []
-    | phi == 0  = [(-b) / (2.0 * a)]
-    | phi > 0   = [ (-b + mySqrt phi) / (2.0 * a) -- not alowed
-                  , (-b - mySqrt phi) / (2.0 * a)
-                  ]
-    where phi = b * b - 4.0 * a * c
-
-solveDegree1 :: Float -> Float -> Float
-solveDegree1 b c = -c / b
-
-solve :: Polynomial -> [Float]
-solve [t0]         = []
-solve [t0, t1]     = [solveDegree1 (coefficient t1) (coefficient t0)]
-solve [t0, t1, t2] = solveDegree2 (coefficient t2) (coefficient t1) (coefficient t0)
-solve _            = undefined
-
-mySqrt :: Float -> Float
-mySqrt n
-  | n < 0     = undefined
-  | otherwise = mySqrt' (n / 2)
-    where mySqrt' x = if abs (x * x - n) < 0.01
-                         then x
-                         else mySqrt' xn
-            where xn = b - (a * a) / (2 * b)
-                    where a = (n - x * x) / (2 * x)
-                          b = x + a
diff --git a/src/statement.hs b/src/statement.hs
deleted file mode 100644
index 75dfdb4..0000000
--- a/src/statement.hs
+++ /dev/null
@@ -1,14 +0,0 @@
-module Statement where
-
-import Assignment
-import Expr
-
-
-data Statement
-    = SAssignment Assignment
-    | SExpr Expr
-
-instance Show Statement where
-    show (SAssignment a) = show a
-    show (SExpr e) = show e
-
-- 
cgit