Merge pull request #16 from davidchambers/triple-quotes

use triple-quoted strings to avoid backslashes

Author: paf31

src/Data/Char/Char.purs

@@ -11,14 +11,18 @@ module Data.Char
   charString (Char s) = s
 
   foreign import toCharCode
-    "function toCharCode(c){\
-    \  return c.charCodeAt(0);\
-    \}" :: Char -> Number
-
-  foreign import fromCharCode 
-    "function fromCharCode(c){\
-    \   return String.fromCharCode(c);\
-    \}" :: Number -> Char
+    """
+    function toCharCode(c) {
+      return c.charCodeAt(0);
+    }
+    """ :: Char -> Number
+
+  foreign import fromCharCode
+    """
+    function fromCharCode(c) {
+      return String.fromCharCode(c);
+    }
+    """ :: Number -> Char
 
   instance eqChar :: Eq Char where
     (==) (Char a) (Char b) = a == b

src/Data/String.purs

@@ -26,10 +26,12 @@ module Data.String
   import Data.Function
 
   foreign import _charAt
-    "function _charAt(i, s, Just, Nothing) {\
-    \  if (i < 0 || i >= s.length) return Nothing;\
-    \  else return Just(s.charAt(i));\
-    \}" :: forall a. Fn4 Number String (a -> Maybe a) (Maybe a) (Maybe Char)
+    """
+    function _charAt(i, s, Just, Nothing) {
+      if (i < 0 || i >= s.length) return Nothing;
+      else return Just(s.charAt(i));
+    }
+    """ :: forall a. Fn4 Number String (a -> Maybe a) (Maybe a) (Maybe Char)
 
   charAt :: Number -> String -> Maybe Char
   charAt n s = runFn4 _charAt n s Just Nothing
@@ -38,116 +40,150 @@ module Data.String
   fromChar = charString
 
   foreign import _charCodeAt
-    "function _charCodeAt(i, s, Just, Nothing) {\
-    \  if (i < 0 || i >= s.length) return Nothing;\
-    \  else return Just(s.charCodeAt(i));\
-    \}" :: forall a. Fn4 Number String (a -> Maybe a) (Maybe a) (Maybe Number)
+    """
+    function _charCodeAt(i, s, Just, Nothing) {
+      if (i < 0 || i >= s.length) return Nothing;
+      else return Just(s.charCodeAt(i));
+    }
+    """ :: forall a. Fn4 Number String (a -> Maybe a) (Maybe a) (Maybe Number)
 
   charCodeAt :: Number -> String -> Maybe Number
   charCodeAt n s = runFn4 _charCodeAt n s Just Nothing
 
   foreign import fromCharArray
-    "function fromCharArray(a) {\
-    \   return a.join('');  \
-    \}" :: [Char] -> String
+    """
+    function fromCharArray(a) {
+      return a.join('');
+    }
+    """ :: [Char] -> String
 
   foreign import indexOf
-    "function indexOf(x) {\
-    \  return function(s) {\
-    \    return s.indexOf(x);\
-    \  }; \
-    \}" :: String -> String -> Number
+    """
+    function indexOf(x) {
+      return function(s) {
+        return s.indexOf(x);
+      };
+    }
+    """ :: String -> String -> Number
 
   foreign import indexOf'
-    "function indexOf$prime(x) {\
-    \  return function(startAt) {\
-    \    return function(s) {\
-    \      return s.indexOf(x, startAt);\
-    \    }; \
-    \  }; \
-    \}" :: String -> Number -> String -> Number
+    """
+    function indexOf$prime(x) {
+      return function(startAt) {
+        return function(s) {
+          return s.indexOf(x, startAt);
+        };
+      };
+    }
+    """ :: String -> Number -> String -> Number
 
   foreign import lastIndexOf
-    "function lastIndexOf(x) {\
-    \  return function(s) {\
-    \    return s.lastIndexOf(x);\
-    \  };\
-    \}" :: String -> String -> Number
+    """
+    function lastIndexOf(x) {
+      return function(s) {
+        return s.lastIndexOf(x);
+      };
+    }
+    """ :: String -> String -> Number
 
   foreign import lastIndexOf'
-    "function lastIndexOf$prime(x) {\
-    \  return function(startAt) {\
-    \    return function(s) {\
-    \      return s.lastIndexOf(x, startAt);\
-    \    }; \
-    \  }; \
-    \}" :: String -> Number -> String -> Number
+    """
+    function lastIndexOf$prime(x) {
+      return function(startAt) {
+        return function(s) {
+          return s.lastIndexOf(x, startAt);
+        };
+      };
+    }
+    """ :: String -> Number -> String -> Number
 
   foreign import length
-    "function length(s) {\
-    \  return s.length;\
-    \}" :: String -> Number
+    """
+    function length(s) {
+      return s.length;
+    }
+    """ :: String -> Number
 
   foreign import localeCompare
-    "function localeCompare(s1) {\
-    \  return function(s2) {\
-    \    return s1.localeCompare(s2);\
-    \  };\
-    \}" :: String -> String -> Number
+    """
+    function localeCompare(s1) {
+      return function(s2) {
+        return s1.localeCompare(s2);
+      };
+    }
+    """ :: String -> String -> Number
 
   foreign import replace
-    "function replace(s1) {\
-    \  return function(s2) {\
-    \    return function(s3) {\
-    \      return s3.replace(s1, s2);\
-    \    };\
-    \  };\
-    \}" :: String -> String -> String -> String
+    """
+    function replace(s1) {
+      return function(s2) {
+        return function(s3) {
+          return s3.replace(s1, s2);
+        };
+      };
+    }
+    """ :: String -> String -> String -> String
 
   foreign import take
-    "function take(n) {\
-    \  return function(s) {\
-    \    return s.substr(0, n);\
-    \  };\
-    \}" :: Number -> String -> String
+    """
+    function take(n) {
+      return function(s) {
+        return s.substr(0, n);
+      };
+    }
+    """ :: Number -> String -> String
 
   foreign import drop
-    "function drop(n) {\
-    \  return function(s) {\
-    \    return s.substr(n);\
-    \  };\
-    \}" :: Number -> String -> String
+    """
+    function drop(n) {
+      return function(s) {
+        return s.substr(n);
+      };
+    }
+    """ :: Number -> String -> String
 
   foreign import split
-    "function split(sep) {\
-    \  return function(s) {\
-    \    return s.split(sep);\
-    \  };\
-    \}" :: String -> String -> [String]
+    """
+    function split(sep) {
+      return function(s) {
+        return s.split(sep);
+      };
+    }
+    """ :: String -> String -> [String]
 
   foreign import toCharArray
-    "function toCharArray(s) {\
-    \   return s.split('');\
-    \}" :: String -> [Char]
+    """
+    function toCharArray(s) {
+      return s.split('');
+    }
+    """ :: String -> [Char]
 
   foreign import toLower
-    "function toLower(s) {\
-    \  return s.toLowerCase();\
-    \}" :: String -> String
+    """
+    function toLower(s) {
+      return s.toLowerCase();
+    }
+    """ :: String -> String
 
   foreign import toUpper
-    "function toUpper(s) {\
-    \  return s.toUpperCase();\
-    \}" :: String -> String
+    """
+    function toUpper(s) {
+      return s.toUpperCase();
+    }
+    """ :: String -> String
 
   foreign import trim
-    "function trim(s) {\
-    \  return s.trim();\
-    \}" :: String -> String
+    """
+    function trim(s) {
+      return s.trim();
+    }
+    """ :: String -> String
 
   foreign import joinWith
-    "function joinWith (s) {\
-    \  return function (xs) {\
-    \    return xs.join(s);\
-    \  };\
-    \}" :: String -> [String] -> String
+    """
+    function joinWith(s) {
+      return function(xs) {
+        return xs.join(s);
+      };
+    }
+    """ :: String -> [String] -> String