refactor: WithDefault -> Or

glennsl · glennsl · commit 4f105a12c025 · 2023-07-12T14:48:03.000+02:00
diff --git a/src/Core__Null.mjs b/src/Core__Null.mjs
@@ -20,7 +20,7 @@ function compare(a, b, cmp) {
   return Core__Option.compare(a === null ? undefined : Caml_option.some(a), b === null ? undefined : Caml_option.some(b), cmp);
 }
 
-function getWithDefault(value, $$default) {
+function getOr(value, $$default) {
   if (value !== null) {
     return value;
   } else {
@@ -47,7 +47,7 @@ function map(value, f) {
   }
 }
 
-function mapWithDefault(value, $$default, f) {
+function mapOr(value, $$default, f) {
   if (value !== null) {
     return Curry._1(f, value);
   } else {
@@ -63,13 +63,19 @@ function flatMap(value, f) {
   }
 }
 
+var getWithDefault = getOr;
+
+var mapWithDefault = mapOr;
+
 export {
   equal ,
   compare ,
   fromOption ,
+  getOr ,
   getWithDefault ,
   getExn ,
   map ,
+  mapOr ,
   mapWithDefault ,
   flatMap ,
 }
diff --git a/src/Core__Null.res b/src/Core__Null.res
@@ -18,12 +18,14 @@ let equal = (a, b, eq) => Core__Option.equal(a->toOption, b->toOption, eq)
 
 let compare = (a, b, cmp) => Core__Option.compare(a->toOption, b->toOption, cmp)
 
-let getWithDefault = (value, default) =>
+let getOr = (value, default) =>
   switch value->toOption {
   | Some(x) => x
   | None => default
   }
 
+let getWithDefault = getOr
+
 let getExn: t<'a> => 'a = value =>
   switch value->toOption {
   | Some(x) => x
@@ -38,12 +40,14 @@ let map = (value, f) =>
   | None => null
   }
 
-let mapWithDefault = (value, default, f) =>
+let mapOr = (value, default, f) =>
   switch value->toOption {
   | Some(x) => f(x)
   | None => default
   }
 
+let mapWithDefault = mapOr
+
 let flatMap = (value, f) =>
   switch value->toOption {
   | Some(x) => f(x)
diff --git a/src/Core__Null.resi b/src/Core__Null.resi
@@ -77,22 +77,25 @@ Console.log(asNull == null) // Logs `true` to the console.
 let fromOption: option<'a> => t<'a>
 
 /**
-`getWithDefault(value, default)` returns `value` if not `null`, otherwise return
+`getOr(value, default)` returns `value` if not `null`, otherwise return
 `default`.
 
 ## Examples
 
 ```rescript
-Null.getWithDefault(null, "Banana") // Banana
-Null.getWithDefault(Nulalble.make("Apple"), "Banana") // Apple
+Null.getOr(null, "Banana") // Banana
+Null.getOr(Nulalble.make("Apple"), "Banana") // Apple
 
 let greet = (firstName: option<string>) =>
-  "Greetings " ++ firstName->Null.getWithDefault("Anonymous")
+  "Greetings " ++ firstName->Null.getOr("Anonymous")
 
 Null.make("Jane")->greet // "Greetings Jane"
 null->greet // "Greetings Anonymous"
 ```
 */
+let getOr: (t<'a>, 'a) => 'a
+
+@deprecated("Use getOr instead")
 let getWithDefault: (t<'a>, 'a) => 'a
 
 /**
@@ -139,19 +142,22 @@ Null.map(null, x => x * x) // null
 let map: (t<'a>, 'a => 'b) => t<'b>
 
 /**
-`mapWithDefault(value, default, f)` returns `f(value)` if `value` is not `null`,
+`mapOr(value, default, f)` returns `f(value)` if `value` is not `null`,
 otherwise returns `default`.
 
 ## Examples
 
 ```rescript
 let someValue = Null.make(3)
-someValue->Null.mapWithDefault(0, x => x + 5) // 8
+someValue->Null.mapOr(0, x => x + 5) // 8
 
 let noneValue = null
-noneValue->Null.mapWithDefault(0, x => x + 5) // 0
+noneValue->Null.mapOr(0, x => x + 5) // 0
 ```
 */
+let mapOr: (t<'a>, 'b, 'a => 'b) => 'b
+
+@deprecated("Use mapOr instead")
 let mapWithDefault: (t<'a>, 'b, 'a => 'b) => 'b
 
 /**
diff --git a/src/Core__Nullable.mjs b/src/Core__Nullable.mjs
@@ -19,7 +19,7 @@ function compare(a, b, cmp) {
   return Core__Option.compare((a == null) ? undefined : Caml_option.some(a), (b == null) ? undefined : Caml_option.some(b), cmp);
 }
 
-function getWithDefault(value, $$default) {
+function getOr(value, $$default) {
   if (value == null) {
     return $$default;
   } else {
@@ -46,7 +46,7 @@ function map(value, f) {
   }
 }
 
-function mapWithDefault(value, $$default, f) {
+function mapOr(value, $$default, f) {
   if (value == null) {
     return $$default;
   } else {
@@ -62,13 +62,19 @@ function flatMap(value, f) {
   }
 }
 
+var getWithDefault = getOr;
+
+var mapWithDefault = mapOr;
+
 export {
   equal ,
   compare ,
   fromOption ,
+  getOr ,
   getWithDefault ,
   getExn ,
   map ,
+  mapOr ,
   mapWithDefault ,
   flatMap ,
 }
diff --git a/src/Core__Nullable.res b/src/Core__Nullable.res
@@ -18,12 +18,14 @@ let equal = (a, b, eq) => Core__Option.equal(a->toOption, b->toOption, eq)
 
 let compare = (a, b, cmp) => Core__Option.compare(a->toOption, b->toOption, cmp)
 
-let getWithDefault = (value, default) =>
+let getOr = (value, default) =>
   switch value->toOption {
   | Some(x) => x
   | None => default
   }
 
+let getWithDefault = getOr
+
 let getExn: t<'a> => 'a = value =>
   switch value->toOption {
   | Some(x) => x
@@ -38,12 +40,14 @@ let map = (value, f) =>
   | None => Obj.magic(value)
   }
 
-let mapWithDefault = (value, default, f) =>
+let mapOr = (value, default, f) =>
   switch value->toOption {
   | Some(x) => f(x)
   | None => default
   }
 
+let mapWithDefault = mapOr
+
 let flatMap = (value, f) =>
   switch value->toOption {
   | Some(x) => f(x)
diff --git a/src/Core__Nullable.resi b/src/Core__Nullable.resi
@@ -87,22 +87,25 @@ let asNullable = optString->Nullable.fromOption // Nullable.t<string>
 let fromOption: option<'a> => t<'a>
 
 /**
-`getWithDefault(value, default)` returns `value` if not `null` or `undefined`,
+`getOr(value, default)` returns `value` if not `null` or `undefined`,
 otherwise return `default`.
 
 ## Examples
 
 ```rescript
-Nullable.getWithDefault(Nullable.null, "Banana") // Banana
-Nullable.getWithDefault(Nulalble.make("Apple"), "Banana") // Apple
+Nullable.getOr(Nullable.null, "Banana") // Banana
+Nullable.getOr(Nulalble.make("Apple"), "Banana") // Apple
 
 let greet = (firstName: option<string>) =>
-  "Greetings " ++ firstName->Nullable.getWithDefault("Anonymous")
+  "Greetings " ++ firstName->Nullable.getOr("Anonymous")
 
 Nullable.make("Jane")->greet // "Greetings Jane"
 Nullable.null->greet // "Greetings Anonymous"
 ```
 */
+let getOr: (t<'a>, 'a) => 'a
+
+@deprecated("Use getOr instead")
 let getWithDefault: (t<'a>, 'a) => 'a
 
 /**
@@ -149,19 +152,22 @@ Nullable.map(undefined, x => x * x) // undefined
 let map: (t<'a>, 'a => 'b) => t<'b>
 
 /**
-`mapWithDefault(value, default, f)` returns `f(value)` if `value` is not `null`
+`mapOr(value, default, f)` returns `f(value)` if `value` is not `null`
 or `undefined`, otherwise returns `default`.
 
 ## Examples
 
 ```rescript
 let someValue = Nullable.make(3)
-someValue->Nullable.mapWithDefault(0, x => x + 5) // 8
+someValue->Nullable.mapOr(0, x => x + 5) // 8
 
 let noneValue = Nullable.null
-noneValue->Nullable.mapWithDefault(0, x => x + 5) // 0
+noneValue->Nullable.mapOr(0, x => x + 5) // 0
 ```
 */
+let mapOr: (t<'a>, 'b, 'a => 'b) => 'b
+
+@deprecated("Use mapOr instead")
 let mapWithDefault: (t<'a>, 'b, 'a => 'b) => 'b
 
 /**
diff --git a/src/Core__Option.mjs b/src/Core__Option.mjs
@@ -29,7 +29,7 @@ function getExn(x) {
       };
 }
 
-function mapWithDefault(opt, $$default, f) {
+function mapOr(opt, $$default, f) {
   var f$1 = Curry.__1(f);
   if (opt !== undefined) {
     return f$1(Caml_option.valFromOption(opt));
@@ -54,7 +54,7 @@ function flatMap(opt, f) {
   
 }
 
-function getWithDefault(opt, $$default) {
+function getOr(opt, $$default) {
   if (opt !== undefined) {
     return Caml_option.valFromOption(opt);
   } else {
@@ -104,13 +104,19 @@ function compare(a, b, cmp) {
   }
 }
 
+var mapWithDefault = mapOr;
+
+var getWithDefault = getOr;
+
 export {
   filter ,
   forEach ,
   getExn ,
+  mapOr ,
   mapWithDefault ,
   map ,
   flatMap ,
+  getOr ,
   getWithDefault ,
   orElse ,
   isSome ,
diff --git a/src/Core__Option.res b/src/Core__Option.res
@@ -46,13 +46,15 @@ let getExn = x =>
 
 external getUnsafe: option<'a> => 'a = "%identity"
 
-let mapWithDefaultU = (opt, default, f) =>
+let mapOrU = (opt, default, f) =>
   switch opt {
   | Some(x) => f(. x)
   | None => default
   }
 
-let mapWithDefault = (opt, default, f) => mapWithDefaultU(opt, default, (. x) => f(x))
+let mapOr = (opt, default, f) => mapOrU(opt, default, (. x) => f(x))
+
+let mapWithDefault = mapOr
 
 let mapU = (opt, f) =>
   switch opt {
@@ -70,12 +72,14 @@ let flatMapU = (opt, f) =>
 
 let flatMap = (opt, f) => flatMapU(opt, (. x) => f(x))
 
-let getWithDefault = (opt, default) =>
+let getOr = (opt, default) =>
   switch opt {
   | Some(x) => x
   | None => default
   }
 
+let getWithDefault = getOr
+
 let orElse = (opt, other) =>
   switch opt {
   | Some(_) as some => some
diff --git a/src/Core__Option.resi b/src/Core__Option.resi
@@ -96,18 +96,21 @@ Option.getUnsafe(None: option<int>) // Returns `undefined`, which is not a valid
 external getUnsafe: option<'a> => 'a = "%identity"
 
 /**
-`mapWithDefault(opt, default, f)` returns `f(value)` if `opt` is `Some(value)`, otherwise `default`.
+`mapOr(opt, default, f)` returns `f(value)` if `opt` is `Some(value)`, otherwise `default`.
 
 ## Examples
 
 ```rescript
 let someValue = Some(3)
-someValue->Option.mapWithDefault(0, x => x + 5) // 8
+someValue->Option.mapOr(0, x => x + 5) // 8
 
 let noneValue = None
-noneValue->Option.mapWithDefault(0, x => x + 5) // 0
+noneValue->Option.mapOr(0, x => x + 5) // 0
 ```
 */
+let mapOr: (option<'a>, 'b, 'a => 'b) => 'b
+
+@deprecated("Use mapOr instead")
 let mapWithDefault: (option<'a>, 'b, 'a => 'b) => 'b
 
 /**
@@ -143,21 +146,24 @@ Option.flatMap(None, addIfAboveOne) // None
 let flatMap: (option<'a>, 'a => option<'b>) => option<'b>
 
 /**
-`getWithDefault(opt, default)` returns `value` if `opt` is `Some(value)`, otherwise `default`.
+`getOr(opt, default)` returns `value` if `opt` is `Some(value)`, otherwise `default`.
 
 ## Examples
 
 ```rescript
-Option.getWithDefault(None, "Banana") // Banana
-Option.getWithDefault(Some("Apple"), "Banana") // Apple
+Option.getOr(None, "Banana") // Banana
+Option.getOr(Some("Apple"), "Banana") // Apple
 
 let greet = (firstName: option<string>) =>
-  "Greetings " ++ firstName->Option.getWithDefault("Anonymous")
+  "Greetings " ++ firstName->Option.getOr("Anonymous")
 
 Some("Jane")->greet // "Greetings Jane"
 None->greet // "Greetings Anonymous"
 ```
 */
+let getOr: (option<'a>, 'a) => 'a
+
+@deprecated("Use getOr instead")
 let getWithDefault: (option<'a>, 'a) => 'a
 
 /**
diff --git a/src/Core__Result.mjs b/src/Core__Result.mjs
diff --git a/src/Core__Result.res b/src/Core__Result.res
diff --git a/src/Core__Result.resi b/src/Core__Result.resi

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ function compare(a, b, cmp) {`
`20`	`20`	`return Core__Option.compare(a === null ? undefined : Caml_option.some(a), b === null ? undefined : Caml_option.some(b), cmp);`
`21`	`21`	`}`
`22`	`22`
`23`		`-function getWithDefault(value, $$default) {`
	`23`	`+function getOr(value, $$default) {`
`24`	`24`	`if (value !== null) {`
`25`	`25`	`return value;`
`26`	`26`	`} else {`
`@@ -47,7 +47,7 @@ function map(value, f) {`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`		`-function mapWithDefault(value, $$default, f) {`
	`50`	`+function mapOr(value, $$default, f) {`
`51`	`51`	`if (value !== null) {`
`52`	`52`	`return Curry._1(f, value);`
`53`	`53`	`} else {`
`@@ -63,13 +63,19 @@ function flatMap(value, f) {`
`63`	`63`	`}`
`64`	`64`	`}`
`65`	`65`
	`66`	`+var getWithDefault = getOr;`
	`67`	`+`
	`68`	`+var mapWithDefault = mapOr;`
	`69`	`+`
`66`	`70`	`export {`
`67`	`71`	`equal ,`
`68`	`72`	`compare ,`
`69`	`73`	`fromOption ,`
	`74`	`+ getOr ,`
`70`	`75`	`getWithDefault ,`
`71`	`76`	`getExn ,`
`72`	`77`	`map ,`
	`78`	`+ mapOr ,`
`73`	`79`	`mapWithDefault ,`
`74`	`80`	`flatMap ,`
`75`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ function compare(a, b, cmp) {`
`19`	`19`	`return Core__Option.compare((a == null) ? undefined : Caml_option.some(a), (b == null) ? undefined : Caml_option.some(b), cmp);`
`20`	`20`	`}`
`21`	`21`
`22`		`-function getWithDefault(value, $$default) {`
	`22`	`+function getOr(value, $$default) {`
`23`	`23`	`if (value == null) {`
`24`	`24`	`return $$default;`
`25`	`25`	`} else {`
`@@ -46,7 +46,7 @@ function map(value, f) {`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`
`49`		`-function mapWithDefault(value, $$default, f) {`
	`49`	`+function mapOr(value, $$default, f) {`
`50`	`50`	`if (value == null) {`
`51`	`51`	`return $$default;`
`52`	`52`	`} else {`
`@@ -62,13 +62,19 @@ function flatMap(value, f) {`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
	`65`	`+var getWithDefault = getOr;`
	`66`	`+`
	`67`	`+var mapWithDefault = mapOr;`
	`68`	`+`
`65`	`69`	`export {`
`66`	`70`	`equal ,`
`67`	`71`	`compare ,`
`68`	`72`	`fromOption ,`
	`73`	`+ getOr ,`
`69`	`74`	`getWithDefault ,`
`70`	`75`	`getExn ,`
`71`	`76`	`map ,`
	`77`	`+ mapOr ,`
`72`	`78`	`mapWithDefault ,`
`73`	`79`	`flatMap ,`
`74`	`80`	`}`