Rename fold functions to case #24

Author: garyb

README.md

@@ -4,7 +4,7 @@
 [![Build Status](https://travis-ci.org/purescript-contrib/purescript-argonaut-core.svg?branch=master)](https://travis-ci.org/purescript-contrib/purescript-argonaut-core)
 [![Maintainer: slamdata](https://img.shields.io/badge/maintainer-slamdata-lightgrey.svg)](http://github.com/slamdata)
 
-Core part of `purescript-argonaut` that contains basic types for `Json`, folds over them, tests, printer and parser.
+Core part of `purescript-argonaut` that contains basic types for `Json`, case analysis, printer and parser.
 
 ## Installation
 
@@ -94,16 +94,16 @@ someObject = A.fromObject (StrMap.fromFoldable [
 
 ### Eliminating/matching on `Json` values
 
-We can perform case analysis for `Json` values using the `foldJson` function.
+We can perform case analysis for `Json` values using the `caseJson` function.
 This function is necessary because `Json` is not an algebraic data type. If
 `Json` were an algebraic data type, we would not have as much need for this
 function, because we could perform pattern matching with a `case ... of`
 expression instead.
 
-The type of `foldJson` is:
+The type of `caseJson` is:
 
 ```purescript
-foldJson
+caseJson
   :: forall a
    . (Unit -> a)
   -> (Boolean -> a)
@@ -115,11 +115,11 @@ foldJson
   -> a
 ```
 
-That is, `foldJson` takes six functions, which all must return values of some
-particular type `a`, together with one `Json` value. `foldJson` itself also
+That is, `caseJson` takes six functions, which all must return values of some
+particular type `a`, together with one `Json` value. `caseJson` itself also
 returns a value of the same type `a`.
 
-A use of `foldJson` is very similar to a `case ... of` expression, as it allows
+A use of `caseJson` is very similar to a `case ... of` expression, as it allows
 you to handle each of the six possibilities for the `Json` value you passed in. Thinking of it this way, each of the six function arguments is like one of the
 case alternatives.
 
@@ -128,7 +128,7 @@ The function that takes `Unit` as an argument is for matching `null` values. As
 Just like in a `case ... of` expression, the final value
 that the whole expression evaluates to comes from evaluating exactly one of the
 'alternatives' (functions) that you pass in. In fact, you can tell that this
-is the case just by looking at the type signature of `foldJson`, because of a
+is the case just by looking at the type signature of `caseJson`, because of a
 property called *parametricity* (although a deeper explanation of parametricity
 is outside the scope of this tutorial).
 
@@ -141,15 +141,15 @@ exports.anotherArray = [0.0, {foo: 'bar'}, false];
 exports.anotherObject = {foo: 1, bar: [2,2]};
 ```
 
-Then we can match on them in PureScript using `foldJson`:
+Then we can match on them in PureScript using `caseJson`:
 
 ```purescript
 foreign import anotherNumber :: Json
 foreign import anotherArray :: Json
 foreign import anotherObject :: Json
 
 basicInfo :: Json -> String
-basicInfo = foldJson
+basicInfo = caseJson
   (const "It was null")
   (\b -> "Got a boolean: " <>
             if b then "it was true!" else "It was false.")
@@ -168,20 +168,20 @@ basicInfo anotherArray  -- => "Got an array, which had 3 items."
 basicInfo anotherObject -- => "Got an object, which had 2 items."
 ```
 
-`foldJson` is the fundamental function for pattern matching on `Json` values;
-any kind of pattern matching you might want to do can be done with `foldJson`.
+`caseJson` is the fundamental function for pattern matching on `Json` values;
+any kind of pattern matching you might want to do can be done with `caseJson`.
 
-However, `foldJson` is not always comfortable to use, so Argonaut provides a
-few other simpler versions for convenience. For example, the `foldJsonX`
+However, `caseJson` is not always comfortable to use, so Argonaut provides a
+few other simpler versions for convenience. For example, the `caseJsonX`
 functions can be used to match on a specific type. The first argument acts as a
 default value, to be used if the `Json` value turned out not to be that type.
 For example, we can write a function which tests whether a JSON value is the
 string "lol" like this:
 
 ```purescript
-foldJsonString :: forall a. a -> (String -> a) -> Json -> a
+caseJsonString :: forall a. a -> (String -> a) -> Json -> a
 
-isJsonLol = foldJsonString false (_ == "lol")
+isJsonLol = caseJsonString false (_ == "lol")
 ```
 
 If the `Json` value is not a string, the default `false` is used. Otherwise,

src/Data/Argonaut/Core.js

@@ -23,7 +23,7 @@ function isArray(a) {
   return objToString.call(a) === "[object Array]";
 }
 
-exports._foldJson = function (isNull, isBool, isNum, isStr, isArr, isObj, j) {
+exports._caseJson = function (isNull, isBool, isNum, isStr, isArr, isObj, j) {
   if (j == null) return isNull();
   else if (typeof j === "boolean") return isBool(j);
   else if (typeof j === "number") return isNum(j);

src/Data/Argonaut/Core.purs

@@ -3,13 +3,13 @@
 -- | for this module.
 module Data.Argonaut.Core
   ( Json
-  , foldJson
-  , foldJsonNull
-  , foldJsonBoolean
-  , foldJsonNumber
-  , foldJsonString
-  , foldJsonArray
-  , foldJsonObject
+  , caseJson
+  , caseJsonNull
+  , caseJsonBoolean
+  , caseJsonNumber
+  , caseJsonString
+  , caseJsonArray
+  , caseJsonObject
   , isNull
   , isBoolean
   , isNumber
@@ -69,7 +69,7 @@ instance ordJNull :: Ord JNull where
   compare _ _ = EQ
 
 -- | Case analysis for `Json` values. See the README for more information.
-foldJson
+caseJson
   :: forall a
    . (Unit -> a)
   -> (Boolean -> a)
@@ -78,62 +78,62 @@ foldJson
   -> (Array Json -> a)
   -> (Object Json -> a)
   -> Json -> a
-foldJson a b c d e f json = runFn7 _foldJson a b c d e f json
+caseJson a b c d e f json = runFn7 _caseJson a b c d e f json
 
--- | A simpler version of `foldJson` which accepts a callback for when the
+-- | A simpler version of `caseJson` which accepts a callback for when the
 -- | `Json` argument was null, and a default value for all other cases.
-foldJsonNull :: forall a. a -> (Unit -> a) -> Json -> a
-foldJsonNull d f j = runFn7 _foldJson f (const d) (const d) (const d) (const d) (const d) j
+caseJsonNull :: forall a. a -> (Unit -> a) -> Json -> a
+caseJsonNull d f j = runFn7 _caseJson f (const d) (const d) (const d) (const d) (const d) j
 
--- | A simpler version of `foldJson` which accepts a callback for when the
+-- | A simpler version of `caseJson` which accepts a callback for when the
 -- | `Json` argument was a `Boolean`, and a default value for all other cases.
-foldJsonBoolean :: forall a. a -> (Boolean -> a) -> Json -> a
-foldJsonBoolean d f j = runFn7 _foldJson (const d) f (const d) (const d) (const d) (const d) j
+caseJsonBoolean :: forall a. a -> (Boolean -> a) -> Json -> a
+caseJsonBoolean d f j = runFn7 _caseJson (const d) f (const d) (const d) (const d) (const d) j
 
--- | A simpler version of `foldJson` which accepts a callback for when the
+-- | A simpler version of `caseJson` which accepts a callback for when the
 -- | `Json` argument was a `Number`, and a default value for all other cases.
-foldJsonNumber :: forall a. a -> (Number -> a) -> Json -> a
-foldJsonNumber d f j = runFn7 _foldJson (const d) (const d) f (const d) (const d) (const d) j
+caseJsonNumber :: forall a. a -> (Number -> a) -> Json -> a
+caseJsonNumber d f j = runFn7 _caseJson (const d) (const d) f (const d) (const d) (const d) j
 
--- | A simpler version of `foldJson` which accepts a callback for when the
+-- | A simpler version of `caseJson` which accepts a callback for when the
 -- | `Json` argument was a `String`, and a default value for all other cases.
-foldJsonString :: forall a. a -> (String -> a) -> Json -> a
-foldJsonString d f j = runFn7 _foldJson (const d) (const d) (const d) f (const d) (const d) j
+caseJsonString :: forall a. a -> (String -> a) -> Json -> a
+caseJsonString d f j = runFn7 _caseJson (const d) (const d) (const d) f (const d) (const d) j
 
--- | A simpler version of `foldJson` which accepts a callback for when the
+-- | A simpler version of `caseJson` which accepts a callback for when the
 -- | `Json` argument was a `Array Json`, and a default value for all other cases.
-foldJsonArray :: forall a. a -> (Array Json -> a) -> Json -> a
-foldJsonArray d f j = runFn7 _foldJson (const d) (const d) (const d) (const d) f (const d) j
+caseJsonArray :: forall a. a -> (Array Json -> a) -> Json -> a
+caseJsonArray d f j = runFn7 _caseJson (const d) (const d) (const d) (const d) f (const d) j
 
--- | A simpler version of `foldJson` which accepts a callback for when the
+-- | A simpler version of `caseJson` which accepts a callback for when the
 -- | `Json` argument was an `Object`, and a default value for all other cases.
-foldJsonObject :: forall a. a -> (Object Json -> a) -> Json -> a
-foldJsonObject d f j = runFn7 _foldJson (const d) (const d) (const d) (const d) (const d) f j
+caseJsonObject :: forall a. a -> (Object Json -> a) -> Json -> a
+caseJsonObject d f j = runFn7 _caseJson (const d) (const d) (const d) (const d) (const d) f j
 
 verbJsonType :: forall a b. b -> (a -> b) -> (b -> (a -> b) -> Json -> b) -> Json -> b
-verbJsonType def f fold = fold def f
+verbJsonType def f g = g def f
 
 -- Tests
 isJsonType :: forall a. (Boolean -> (a -> Boolean) -> Json -> Boolean) -> Json -> Boolean
 isJsonType = verbJsonType false (const true)
 
 isNull :: Json -> Boolean
-isNull = isJsonType foldJsonNull
+isNull = isJsonType caseJsonNull
 
 isBoolean :: Json -> Boolean
-isBoolean = isJsonType foldJsonBoolean
+isBoolean = isJsonType caseJsonBoolean
 
 isNumber :: Json -> Boolean
-isNumber = isJsonType foldJsonNumber
+isNumber = isJsonType caseJsonNumber
 
 isString :: Json -> Boolean
-isString = isJsonType foldJsonString
+isString = isJsonType caseJsonString
 
 isArray :: Json -> Boolean
-isArray = isJsonType foldJsonArray
+isArray = isJsonType caseJsonArray
 
 isObject :: Json -> Boolean
-isObject = isJsonType foldJsonObject
+isObject = isJsonType caseJsonObject
 
 -- Decoding
 
@@ -145,22 +145,22 @@ toJsonType
 toJsonType = verbJsonType Nothing Just
 
 toNull :: Json -> Maybe Unit
-toNull = toJsonType foldJsonNull
+toNull = toJsonType caseJsonNull
 
 toBoolean :: Json -> Maybe Boolean
-toBoolean = toJsonType foldJsonBoolean
+toBoolean = toJsonType caseJsonBoolean
 
 toNumber :: Json -> Maybe Number
-toNumber = toJsonType foldJsonNumber
+toNumber = toJsonType caseJsonNumber
 
 toString :: Json -> Maybe String
-toString = toJsonType foldJsonString
+toString = toJsonType caseJsonString
 
 toArray :: Json -> Maybe (Array Json)
-toArray = toJsonType foldJsonArray
+toArray = toJsonType caseJsonArray
 
 toObject :: Json -> Maybe (Object Json)
-toObject = toJsonType foldJsonObject
+toObject = toJsonType caseJsonObject
 
 -- Encoding
 
@@ -200,7 +200,7 @@ jsonSingletonObject key val = fromObject (Obj.singleton key val)
 
 foreign import stringify :: Json -> String
 
-foreign import _foldJson
+foreign import _caseJson
   :: forall z
    . Fn7
       (Unit -> z)