Merge pull request #191 from mumuki/issue#189-chars-and-single-char-s…

…trings-should-be-different

Issue#189 chars and single char strings should be different

README.md

@@ -162,7 +162,7 @@ Mulang is three different  - but thighly related - things:
     + [`MuObject`](#muobject)
       - [Syntax](#syntax-43)
       - [JavaScript Example](#javascript-example)
-    + [`MuNumber`, `MuBool`, `MuString` and `MuSymbol`](#munumber-mubool-mustring-and-musymbol)
+    + [`MuNumber`, `MuBool`, `MuString`, `MuSymbol` and `MuChar`](#munumber-mubool-mustring-musymbol-and-muchar)
       - [Syntax](#syntax-44)
       - [Ruby Example](#ruby-example-5)
     + [`MuTuple` and `MuList`](#mutuple-and-mulist)
@@ -1666,9 +1666,9 @@ for (var i = 0; i < 10; i++) {
             (Attribute "bar" (MuNumber 2))]))
 ```
 
-### `MuNumber`, `MuBool`, `MuString` and `MuSymbol`
+### `MuNumber`, `MuBool`, `MuString`, `MuSymbol` and `MuChar`
 
-> Generic number, boolean, string and symbol (atoms) literals
+> Generic number, boolean, string, symbol (atoms) and char literals
 
 #### Syntax
 
@@ -1688,6 +1688,10 @@ for (var i = 0; i < 10; i++) {
 (MuSymbol String)
 ```
 
+```haskell
+(MuChar Char)
+```
+
 #### Ruby Example
 
 ```ruby

spec/HaskellSpec.hs

@@ -42,3 +42,9 @@ spec = do
 
     it "parses inline type annotations with restrictions" $ do
       hs "x = 1 :: (Num a, Foldable t) => t a" `shouldBe` Variable "x" (TypeCast (MuNumber 1) (SimpleType "t a" ["Num a", "Foldable t"]))
+
+    it "parses chars and single char strings differently" $ do
+      hs "x = \"a\"" `shouldNotBe` hs "x = 'a'"
+
+    it "parses chars as MuChars" $ do
+      hs "x = 'a'" `shouldBe` Variable "x" (MuChar 'a')

spec/JavaSpec.hs

@@ -125,7 +125,7 @@ spec = do
              public char hello() { return 'f'; }
           }|] `shouldBe` Class "Foo" Nothing (Sequence [
                           SubroutineSignature "hello" [] "char" [],
-                          (SimpleMethod "hello" [] (Return (MuString "f")))])
+                          (SimpleMethod "hello" [] (Return (MuChar 'f')))])
 
     it "parses Parameters" $ do
       run "public class Foo extends Bar { int succ(int y) {} }" `shouldBe` Class "Foo" (Just "Bar") (Sequence [

src/Language/Mulang/Ast.hs

@@ -181,6 +181,8 @@ data Expression
     -- ^ Generic boolean literal
     | MuString String
     -- ^ Generic string literal
+    | MuChar Char
+    -- ^ Generic char literal
     | MuSymbol String
     -- ^ Generic symbol/atom literal
     | MuTuple [Expression]

src/Language/Mulang/Inspector/Generic/Duplication.hs

@@ -12,10 +12,11 @@ hasCodeDuplication e =  hasDuplicates $ map hash $ filter (not . isLightweight)
 isLightweight :: Inspection
 isLightweight (MuNumber _)              = True
 isLightweight (MuString _)              = True
+isLightweight (MuChar _)                = True
 isLightweight (MuBool _)                = True
 isLightweight (Reference _)             = True
 isLightweight Self                      = True
-isLightweight None                    = True
+isLightweight None                      = True
 isLightweight MuNil                     = True
 isLightweight Equal                     = True
 isLightweight (Application _ es)        = not $ any isApplication es
@@ -43,6 +44,7 @@ hash (SimpleFunction _ _ body)     = 13 * (37 + hash body)
 hash Self                          = 15
 hash (SimpleProcedure _ _ body)    = 17 * (37 + hash body)
 hash (Sequence es)                 = 19 * (37 + positionalHash es)
+hash (MuChar e)                    = 23 * H.hash e
 hash _                             = 1
 
 positionalHash :: [Expression] -> Int

src/Language/Mulang/Parsers/Haskell.hs

@@ -95,9 +95,9 @@ mu (HsModule _ _ _ _ decls) = compact (concatMap muDecls decls)
     muExp (HsExpTypeSig _ exp (HsQualType cs t))          = TypeCast (muExp exp) (muType t cs)
     muExp e = debug e
 
-    muLit (HsCharPrim    v) = MuString [v]
+    muLit (HsCharPrim    v) = MuChar v
     muLit (HsStringPrim  v) = MuString v
-    muLit (HsChar        v) = MuString [v]
+    muLit (HsChar        v) = MuChar v
     muLit (HsString      v) = MuString v
     muLit (HsIntPrim     v) = MuNumber . fromIntegral $ v
     muLit (HsInt         v) = MuNumber . fromIntegral $ v

src/Language/Mulang/Parsers/Java.hs

@@ -129,7 +129,7 @@ muLhs (NameLhs (Name names)) = ns names
 muName (Name names) = Reference . ns $ names
 
 muLit (String s)  = MuString s
-muLit (Char c)    = MuString [c]
+muLit (Char c)    = MuChar c
 muLit (Int i)     = MuNumber (fromIntegral i)
 muLit (Float d)   = MuNumber d
 muLit (Double d)  = MuNumber d