Rename to workaround issue with hasOwnProperty

Re. #1249 (comment)

src/Monoid.ts

@@ -141,7 +141,7 @@ export const reverse = <A>(M: Monoid<A>): Monoid<A> => ({
 export const struct = <A>(monoids: { [K in keyof A]: Monoid<A[K]> }): Monoid<{ readonly [K in keyof A]: A[K] }> => {
   const empty: A = {} as any
   for (const k in monoids) {
-    if (_.hasOwnProperty.call(monoids, k)) {
+    if (_.has.call(monoids, k)) {
       empty[k] = monoids[k].empty
     }
   }

src/ReadonlyRecord.ts

@@ -71,7 +71,7 @@ export const size = (r: ReadonlyRecord<string, unknown>): number => Object.keys(
  */
 export const isEmpty = (r: ReadonlyRecord<string, unknown>): boolean => {
   for (const k in r) {
-    if (_.hasOwnProperty.call(r, k)) {
+    if (_.has.call(r, k)) {
       return false
     }
   }
@@ -144,7 +144,7 @@ export function toUnfoldable<F>(U: Unfoldable<F>): <A>(r: ReadonlyRecord<string,
  * @since 2.10.0
  */
 export const upsertAt = <A>(k: string, a: A) => (r: ReadonlyRecord<string, A>): ReadonlyRecord<string, A> => {
-  if (_.hasOwnProperty.call(r, k) && r[k] === a) {
+  if (_.has.call(r, k) && r[k] === a) {
     return r
   }
   const out: Record<string, A> = Object.assign({}, r)
@@ -159,7 +159,7 @@ export const upsertAt = <A>(k: string, a: A) => (r: ReadonlyRecord<string, A>):
  *
  * @since 2.10.0
  */
-export const has = <K extends string>(k: string, r: ReadonlyRecord<K, unknown>): k is K => _.hasOwnProperty.call(r, k)
+export const has = <K extends string>(k: string, r: ReadonlyRecord<K, unknown>): k is K => _.has.call(r, k)
 
 /**
  * Delete a key and value from a `ReadonlyRecord`.
@@ -172,7 +172,7 @@ export function deleteAt<K extends string>(
 ): <KS extends string, A>(r: ReadonlyRecord<KS, A>) => ReadonlyRecord<string extends K ? string : Exclude<KS, K>, A>
 export function deleteAt(k: string): <A>(r: ReadonlyRecord<string, A>) => ReadonlyRecord<string, A> {
   return <A>(r: ReadonlyRecord<string, A>) => {
-    if (!_.hasOwnProperty.call(r, k)) {
+    if (!_.has.call(r, k)) {
       return r
     }
     const out: Record<string, A> = Object.assign({}, r)
@@ -258,7 +258,7 @@ export function isSubrecord<A>(
       return (that) => isSubrecordE(that, me)
     }
     for (const k in me) {
-      if (!_.hasOwnProperty.call(that, k) || !E.equals(me[k], that[k])) {
+      if (!_.has.call(that, k) || !E.equals(me[k], that[k])) {
         return false
       }
     }
@@ -281,7 +281,7 @@ export function lookup<A>(
   if (r === undefined) {
     return (r) => lookup(k, r)
   }
-  return _.hasOwnProperty.call(r, k) ? O.some(r[k]) : O.none
+  return _.has.call(r, k) ? O.some(r[k]) : O.none
 }
 
 /**
@@ -304,7 +304,7 @@ export function mapWithIndex<A, B>(
   return (r) => {
     const out: Record<string, B> = {}
     for (const k in r) {
-      if (_.hasOwnProperty.call(r, k)) {
+      if (_.has.call(r, k)) {
         out[k] = f(k, r[k])
       }
     }
@@ -548,7 +548,7 @@ export function partitionMapWithIndex<A, B, C>(
     const left: Record<string, B> = {}
     const right: Record<string, C> = {}
     for (const k in r) {
-      if (_.hasOwnProperty.call(r, k)) {
+      if (_.has.call(r, k)) {
         const e = f(k, r[k])
         switch (e._tag) {
           case 'Left':
@@ -580,7 +580,7 @@ export function partitionWithIndex<A>(
     const left: Record<string, A> = {}
     const right: Record<string, A> = {}
     for (const k in r) {
-      if (_.hasOwnProperty.call(r, k)) {
+      if (_.has.call(r, k)) {
         const a = r[k]
         if (predicateWithIndex(k, a)) {
           right[k] = a
@@ -606,7 +606,7 @@ export function filterMapWithIndex<A, B>(
   return (r) => {
     const out: Record<string, B> = {}
     for (const k in r) {
-      if (_.hasOwnProperty.call(r, k)) {
+      if (_.has.call(r, k)) {
         const ob = f(k, r[k])
         if (_.isSome(ob)) {
           out[k] = ob.value
@@ -633,7 +633,7 @@ export function filterWithIndex<A>(
     const out: Record<string, A> = {}
     let changed = false
     for (const key in fa) {
-      if (_.hasOwnProperty.call(fa, key)) {
+      if (_.has.call(fa, key)) {
         const a = fa[key]
         if (predicateWithIndex(key, a)) {
           out[key] = a
@@ -734,7 +734,7 @@ export function fromFoldableMap<F, B>(
   return <A>(ta: HKT<F, A>, f: (a: A) => readonly [string, B]) => {
     return F.reduce<A, Record<string, B>>(ta, {}, (r, a) => {
       const [k, b] = f(a)
-      r[k] = _.hasOwnProperty.call(r, k) ? M.concat(r[k], b) : b
+      r[k] = _.has.call(r, k) ? M.concat(r[k], b) : b
       return r
     })
   }
@@ -957,7 +957,7 @@ export const reduceRight: <A, B>(b: B, f: (a: A, b: B) => B) => (fa: Readonly<Re
 export const compact = <A>(r: Readonly<Record<string, Option<A>>>): Readonly<Record<string, A>> => {
   const out: Record<string, A> = {}
   for (const k in r) {
-    if (_.hasOwnProperty.call(r, k)) {
+    if (_.has.call(r, k)) {
       const oa = r[k]
       if (_.isSome(oa)) {
         out[k] = oa.value
@@ -977,7 +977,7 @@ export const separate = <A, B>(
   const left: Record<string, A> = {}
   const right: Record<string, B> = {}
   for (const k in r) {
-    if (_.hasOwnProperty.call(r, k)) {
+    if (_.has.call(r, k)) {
       const e = r[k]
       if (_.isLeft(e)) {
         left[k] = e.left
@@ -1059,8 +1059,8 @@ export function getMonoid<A>(S: Semigroup<A>): Monoid<ReadonlyRecord<string, A>>
       }
       const r: Record<string, A> = Object.assign({}, first)
       for (const k in second) {
-        if (_.hasOwnProperty.call(second, k)) {
-          r[k] = _.hasOwnProperty.call(first, k) ? S.concat(first[k], second[k]) : second[k]
+        if (_.has.call(second, k)) {
+          r[k] = _.has.call(first, k) ? S.concat(first[k], second[k]) : second[k]
         }
       }
       return r
@@ -1247,7 +1247,7 @@ export const insertAt: <A>(
  */
 export function hasOwnProperty<K extends string>(k: string, r: ReadonlyRecord<K, unknown>): k is K
 export function hasOwnProperty<K extends string>(this: any, k: string, r?: ReadonlyRecord<K, unknown>): k is K {
-  return _.hasOwnProperty.call(r === undefined ? this : r, k)
+  return _.has.call(r === undefined ? this : r, k)
 }
 
 /**

src/Semigroup.ts

@@ -151,7 +151,7 @@ export const struct = <A>(
   concat: (first, second) => {
     const r: A = {} as any
     for (const k in semigroups) {
-      if (_.hasOwnProperty.call(semigroups, k)) {
+      if (_.has.call(semigroups, k)) {
         r[k] = semigroups[k].concat(first[k], second[k])
       }
     }

src/Show.ts

@@ -35,7 +35,7 @@ export const struct = <A>(shows: { [K in keyof A]: Show<A[K]> }): Show<{ readonl
   show: (a) => {
     let s = '{'
     for (const k in shows) {
-      if (_.hasOwnProperty.call(shows, k)) {
+      if (_.has.call(shows, k)) {
         s += ` ${k}: ${shows[k].show(a[k])},`
       }
     }

src/internal.ts

@@ -25,7 +25,7 @@ export const isLeft = <E, A>(ma: Either<E, A>): ma is Left<E> => ma._tag === 'Le
 // -------------------------------------------------------------------------------------
 
 /** @internal */
-export const hasOwnProperty = Object.prototype.hasOwnProperty
+export const has = Object.prototype.hasOwnProperty
 
 // -------------------------------------------------------------------------------------
 // NonEmptyArray