From bd2d2d91b8c87554328298281314cd929152cc80 Mon Sep 17 00:00:00 2001 From: piq9117 Date: Thu, 22 Mar 2018 19:01:21 -0500 Subject: [PATCH] Sanctuary replaced all Array inputs to ReadonlyArray. --- types/sanctuary/index.d.ts | 75 +++++++++++++++++++------------------- 1 file changed, 38 insertions(+), 37 deletions(-) diff --git a/types/sanctuary/index.d.ts b/types/sanctuary/index.d.ts index 0d61fe22aa..b0a8fd7750 100644 --- a/types/sanctuary/index.d.ts +++ b/types/sanctuary/index.d.ts @@ -2,6 +2,7 @@ // Project: https://github.com/sanctuary-js/sanctuary#readme // Definitions by: David Chambers // Juan J. Jimenez-Anca +// Ken Aguilar // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped declare var S: Sanctuary.Environment; @@ -73,12 +74,12 @@ interface Contravariant {} interface ListToMaybeList { (xs: string): Maybe; - (xs: A[]): Maybe; + (xs: ReadonlyArray): Maybe; } interface MatchObj { match: string; - groups: Array>; + groups: ReadonlyArray>; } declare namespace Sanctuary { @@ -108,13 +109,13 @@ declare namespace Sanctuary { max(x: Ord): (y: Ord) => A; id(p: TypeRep): Fn | Category; concat(x: Semigroup): (y: Semigroup) => Semigroup; - concat(x: A[]): (y: A[]) => A[]; + concat(x: ReadonlyArray): (y: ReadonlyArray) => A[]; concat(x: StrMap): (y: StrMap) => StrMap; concat(x: string): (y: string) => string; empty(p: TypeRep): Monoid; map(p: Fn): { (q: Fn): Fn; - (q: A[]): B[]; + (q: ReadonlyArray): B[]; (q: StrMap): StrMap; (q: Functor): Functor; }; @@ -125,7 +126,7 @@ declare namespace Sanctuary { }; alt(x: Alt): (y: Alt) => Alt; zero(p: TypeRep): Plus; - reduce(p: Fn2): (q: B) => (r: A[] | StrMap | Maybe | Either | Foldable) => B; + reduce(p: Fn2): (q: B) => (r: ReadonlyArray | StrMap | Maybe | Either | Foldable) => B; traverse(typeRep: TypeRep): (f: Fn>) => (traversable: Traversable) => Applicative>; sequence(typeRep: TypeRep): (traversable: Traversable>) => Applicative>; ap(p: Apply>): (q: Apply) => Apply; @@ -144,7 +145,7 @@ declare namespace Sanctuary { chain(f: Fn2): (chain_: Fn) => Fn; chain(f: Fn >): (chain_: Chain) => Chain; join(chain_: Fn2): Fn; - join(chain_: A[][]): A[]; + join(chain_: ReadonlyArray>): A[]; join(chain_: Maybe>): Maybe; join(chain_: Chain>): Chain; chainRec(typeRep: TypeRep): { @@ -158,11 +159,11 @@ declare namespace Sanctuary { (contravariant: Contravariant): Contravariant; }; filter (pred: Predicate): { - (m: A[]): A[]; + (m: ReadonlyArray): A[]; (m: Foldable): Foldable; }; filterM(pred: Predicate): { - (m: A[]): A[]; + (m: ReadonlyArray): A[]; (m: Foldable): Foldable; }; takeWhile(pred: Predicate): (foldable: Foldable) => Foldable; @@ -185,7 +186,7 @@ declare namespace Sanctuary { pipe(fs: [Fn, Fn, Fn]): (x: A) => D; pipe(fs: [Fn, Fn, Fn, Fn]): (x: A) => E; pipe(fs: [Fn, Fn, Fn, Fn, Fn]): (x: A) => F; - pipe(fs: Array>): (x: any) => any; + pipe(fs: ReadonlyArray>): (x: any) => any; on(p: Fn2): (q: Fn) => (r: A) => Fn; // TODO: Maybe isNothing(p: Maybe): boolean; @@ -196,7 +197,7 @@ declare namespace Sanctuary { toMaybe(p: A | null | undefined): Maybe; maybe(p: B): (q: Fn) => (r: Maybe) => B; maybe_(p: Thunk): (q: Fn) => (r: Maybe) => B; - justs(p: Array>): A[]; + justs(p: ReadonlyArray>): A[]; mapMaybe(p: Fn>): (q: A[]) => A[]; encase(p: Fn): Fn>; encase2(p: Fn2): Fn2>; @@ -208,8 +209,8 @@ declare namespace Sanctuary { fromEither(p: B): (q: Either) => B; toEither(p: A): (q: B | null | undefined) => Either; either(p: Fn): (q: Fn) => (r: Either) => C; - lefts(p: Array>): A[]; - rights(p: Array>): B[]; + lefts(p: ReadonlyArray>): A[]; + rights(p: ReadonlyArray>): B[]; tagBy(p: Predicate): (q: A) => Either; encaseEither(p: Fn): (q: Fn) => Fn>; encaseEither2(p: Fn): (q: Fn2) => Fn2>; @@ -223,22 +224,22 @@ declare namespace Sanctuary { ifElse(p: Predicate): (q: Fn) => (r: Fn) => Fn; when(p: Predicate): (q: Fn) => Fn; unless(p: Predicate): (q: Fn) => Fn; - allPass(p: Array>): Predicate; - anyPass(p: Array>): Predicate; + allPass(p: ReadonlyArray>): Predicate; + anyPass(p: ReadonlyArray>): Predicate; // List slice(p: Integer): (q: Integer) => ListToMaybeList; at(p: Integer): { (q: string): Maybe; - (q: A[]): Maybe; + (q: ReadonlyArray): Maybe; }; head(xs: string): Maybe; - head(xs: A[]): Maybe; + head(xs: ReadonlyArray): Maybe; last(xs: string): Maybe; - last(xs: A[]): Maybe; + last(xs: ReadonlyArray): Maybe; tail(xs: string): Maybe; - tail(xs: A[]): Maybe; + tail(xs: ReadonlyArray): Maybe; init(xs: string): Maybe; - init(xs: A[]): Maybe; + init(xs: ReadonlyArray): Maybe; take(n: Integer): ListToMaybeList; takeLast(n: Integer): ListToMaybeList; drop(n: Integer): ListToMaybeList; @@ -246,33 +247,33 @@ declare namespace Sanctuary { // Array // TODO: Fantasyland overloads, non-curried versions append(x: A): { - (xs: A[]): A[]; + (xs: ReadonlyArray): A[]; (xs: Applicative): Applicative; }; prepend(x: A): { - (xs: A[]): A[]; + (xs: ReadonlyArray): A[]; (xs: Applicative): Applicative; }; - joinWith(p: string): (q: string[]) => string; - elem(p: A): (q: Foldable | StrMap | A[]) => boolean; - find(p: Predicate): (q: A[] | StrMap | Foldable) => Maybe; + joinWith(p: string): (q: ReadonlyArray) => string; + elem(p: A): (q: Foldable | StrMap | ReadonlyArray) => boolean; + find(p: Predicate): (q: ReadonlyArray | StrMap | Foldable) => Maybe; pluck(key: string): (xs: Functor) => Functor; unfoldr(f: Fn>>): (x: B) => A[]; range(from: Integer): (to: Integer) => Integer[]; - groupBy(f: Fn2): (xs: A[]) => A[][]; - reverse(foldable: A[]): A[]; + groupBy(f: Fn2): (xs: ReadonlyArray) => A[][]; + reverse(foldable: ReadonlyArray): A[]; reverse(foldable: Foldable): Foldable; - sort(foldable: A[]): A[]; + sort(foldable: ReadonlyArray): A[]; sort(foldable: Foldable): Foldable; sortBy(f: Fn>): { - (foldable: A[]): A[]; + (foldable: ReadonlyArray): A[]; (foldable: Foldable): Foldable; }; // Object prop(p: string): (q: any) => any; - props(p: string[]): (q: any) => any; + props(p: ReadonlyArray): (q: any) => any; get(p: Predicate): (q: string) => (r: any) => Maybe; - gets(p: Predicate): (q: string[]) => (r: any) => Maybe; + gets(p: Predicate): (q: ReadonlyArray) => (r: any) => Maybe; // StrMap keys(p: StrMap): string[]; values(p: StrMap): A[]; @@ -280,13 +281,13 @@ declare namespace Sanctuary { // Number negate(n: ValidNumber): ValidNumber; add(p: FiniteNumber): (q: FiniteNumber) => FiniteNumber; - sum(p: Foldable | FiniteNumber[]): FiniteNumber; + sum(p: Foldable | ReadonlyArray): FiniteNumber; sub(p: FiniteNumber): (q: FiniteNumber) => FiniteNumber; mult(x: FiniteNumber): (q: FiniteNumber) => FiniteNumber; - product(p: Foldable | FiniteNumber[]): FiniteNumber; + product(p: Foldable | ReadonlyArray): FiniteNumber; div(p: NonZeroFiniteNumber): (q: FiniteNumber) => FiniteNumber; pow(p: FiniteNumber): (q: FiniteNumber) => FiniteNumber; - mean(p: Foldable | FiniteNumber[]): Maybe; + mean(p: Foldable | ReadonlyArray): Maybe; // Integer even(n: Integer): boolean; odd(n: Integer): boolean; @@ -308,15 +309,15 @@ declare namespace Sanctuary { stripPrefix(prefix: string): (q: string) => Maybe; stripSuffix(suffix: string): (q: string) => Maybe; words(s: string): string[]; - unwords(xs: string[]): string; + unwords(xs: ReadonlyArray): string; lines(s: string): string[]; - unlines(xs: string[]): string; + unlines(xs: ReadonlyArray): string; splitOn(separator: string): (q: string) => string[]; splitOnRegex(pattern: RegExp): (q: string) => string[]; } interface Environment extends Static { - env: any[]; - create(opts: {checkTypes: boolean, env: any[]}): Static; + env: ReadonlyArray; + create(opts: {checkTypes: boolean, env: ReadonlyArray}): Static; } }