@types/prelude-ls

  • Version 1.1.29
  • Published
  • No dependencies
  • MIT license

Install

npm i @types/prelude-ls
yarn add @types/prelude-ls
pnpm add @types/prelude-ls

Overview

TypeScript definitions for prelude.ls 1.1.1

Index

Variables

variable pi

var pi: number;

    variable tau

    var tau: number;

      Functions

      function abs

      abs: (x: number) => number;

        function acos

        acos: (x: number) => number;

          function all

          all: {
          <A>(f: (x: A) => boolean): (xs: A[]) => boolean;
          <A>(f: (x: A) => boolean, xs: A[]): boolean;
          };

            function andList

            andList: <A>(xs: A[]) => boolean;

              function any

              any: {
              <A>(f: (x: A) => boolean): (xs: A[]) => boolean;
              <A>(f: (x: A) => boolean, xs: A[]): boolean;
              };

                function apply

                apply: {
                <A, B>(f: (...args: A[]) => B): (args: A[]) => B;
                <A, B>(f: (...args: A[]) => B, args: A[]): B;
                };

                  function asin

                  asin: (x: number) => number;

                    function at

                    at: { <A>(n: number): (xs: A[]) => A; <A>(n: number, xs: A[]): A };

                      function atan

                      atan: (x: number) => number;

                        function atan2

                        atan2: (x: number, y: number) => number;

                          function breakList

                          breakList: {
                          <A>(p: (x: A) => boolean): (xs: A[]) => [A[], A[]];
                          <A>(p: (x: A) => boolean, xs: A[]): [A[], A[]];
                          };

                            function breakStr

                            breakStr: {
                            (f: (str: string) => boolean): (str: string) => [string, string];
                            (f: (str: string) => boolean, str: string): [string, string];
                            };

                              function camelize

                              camelize: (str: string) => string;

                                function capitalize

                                capitalize: (str: string) => string;

                                  function ceiling

                                  ceiling: (x: number) => number;

                                    function chars

                                    chars: (str: string) => string[];

                                      function compact

                                      compact: {
                                      <A>(xs: A[]): A[];
                                      <A>(object: { [key: string]: A }): { [key: string]: A };
                                      <A>(object: { [key: number]: A }): { [key: number]: A };
                                      };

                                        function concat

                                        concat: <A>(xss: A[][]) => A[];

                                          function concatMap

                                          concatMap: {
                                          <A, B>(f: (x: A) => B[]): (xs: A[]) => B[];
                                          <A, B>(f: (x: A) => B[], xs: A[]): B[];
                                          };

                                            function cos

                                            cos: (x: number) => number;

                                              function countBy

                                              countBy: {
                                              <A, B>(f: (x: A) => B): (xs: A[]) => any;
                                              <A, B>(f: (x: A) => B, xs: A[]): any;
                                              };

                                                function curry

                                                curry: (f: Function) => Function;

                                                  function dasherize

                                                  dasherize: (str: string) => string;

                                                    function difference

                                                    difference: <A>(...xss: A[][]) => A[];

                                                      function div

                                                      div: { (x: number): (y: number) => number; (x: number, y: number): number };

                                                        function drop

                                                        drop: {
                                                        <A>(n: number): (xs: A[]) => A[];
                                                        <A>(n: number, xs: A[]): A[];
                                                        (n: number): (str: string) => string;
                                                        (n: number, str: string): string;
                                                        };

                                                          function dropWhile

                                                          dropWhile: {
                                                          <A>(p: (x: A) => boolean): (xs: A[]) => A[];
                                                          <A>(p: (x: A) => boolean, xs: A[]): A[];
                                                          (f: (str: string) => boolean): (str: string) => string;
                                                          (f: (str: string) => boolean, str: string): string;
                                                          };

                                                            function each

                                                            each: {
                                                            <A>(f: (x: A) => void): (xs: A[]) => A[];
                                                            <A>(f: (x: A) => void, xs: A[]): A[];
                                                            <A>(f: (x: A) => void): (object: { [key: string]: A }) => { [key: string]: A };
                                                            <A>(f: (x: A) => void, object: { [key: string]: A }): { [key: string]: A };
                                                            <A>(f: (x: A) => void): (object: { [key: number]: A }) => { [key: number]: A };
                                                            <A>(f: (x: A) => void, object: { [key: number]: A }): { [key: number]: A };
                                                            };

                                                              function elemIndex

                                                              elemIndex: { <A>(x: A): (xs: A[]) => number; <A>(x: A, xs: A[]): number };

                                                                function elemIndices

                                                                elemIndices: { <A>(x: A): (xs: A[]) => number[]; <A>(x: A, xs: A[]): number[] };

                                                                  function empty

                                                                  empty: {
                                                                  <A>(xs: A[]): boolean;
                                                                  <A>(object: any): boolean;
                                                                  (str: string): boolean;
                                                                  };

                                                                    function even

                                                                    even: (x: number) => boolean;

                                                                      function exp

                                                                      exp: (x: number) => number;

                                                                        function filter

                                                                        filter: {
                                                                        <A>(f: (x: A) => boolean): (xs: A[]) => A[];
                                                                        <A>(f: (x: A) => boolean, xs: A[]): A[];
                                                                        <A>(f: (x: A) => boolean): (object: {
                                                                        [key: string]: A;
                                                                        }) => { [key: string]: A };
                                                                        <A>(f: (x: A) => boolean, object: { [key: string]: A }): { [key: string]: A };
                                                                        <A>(f: (x: A) => boolean): (object: {
                                                                        [key: number]: A;
                                                                        }) => { [key: number]: A };
                                                                        <A>(f: (x: A) => boolean, object: { [key: number]: A }): { [key: number]: A };
                                                                        };

                                                                          function find

                                                                          find: {
                                                                          <A>(f: (x: A) => Boolean): (xs: A[]) => A;
                                                                          <A>(f: (x: A) => Boolean, xs: A[]): A;
                                                                          <A>(f: (x: A) => boolean): (object: { [key: string]: A }) => A;
                                                                          <A>(f: (x: A) => boolean, object: { [key: string]: A }): A;
                                                                          <A>(f: (x: A) => boolean): (object: { [key: number]: A }) => A;
                                                                          <A>(f: (x: A) => boolean, object: { [key: number]: A }): A;
                                                                          };

                                                                            function findIndex

                                                                            findIndex: {
                                                                            <A>(f: (x: A) => boolean): (xs: A[]) => number;
                                                                            <A>(f: (x: A) => boolean, xs: A[]): number;
                                                                            };

                                                                              function findIndices

                                                                              findIndices: {
                                                                              <A>(f: (x: A) => boolean): (xs: A[]) => number[];
                                                                              <A>(f: (x: A) => boolean, xs: A[]): number[];
                                                                              };

                                                                                function fix

                                                                                fix: (f: Function) => Function;

                                                                                  function flatten

                                                                                  flatten: (xs: any[]) => any[];

                                                                                    function flip

                                                                                    flip: {
                                                                                    <A, B, C>(f: (x: A) => (y: B) => C): (y: B) => (x: A) => C;
                                                                                    <A, B, C>(f: (x: A) => (y: B) => C, y: B): (x: A) => C;
                                                                                    <A, B, C>(f: (x: A) => (y: B) => C, y: B, x: A): C;
                                                                                    };

                                                                                      function floor

                                                                                      floor: (x: number) => number;

                                                                                        function fold

                                                                                        fold: {
                                                                                        <A, B>(f: (x: A) => (y: B) => A): (memo: A) => (xs: B[]) => A;
                                                                                        <A, B>(f: (x: A) => (y: B) => A, memo: A): (xs: B[]) => A;
                                                                                        <A, B>(f: (x: A) => (y: B) => A, memo: A, xs: B[]): A;
                                                                                        };

                                                                                          function fold1

                                                                                          fold1: {
                                                                                          <A>(f: (x: A) => (y: A) => A): (xs: A[]) => A;
                                                                                          <A>(f: (x: A) => (y: A) => A, xs: A[]): A;
                                                                                          };

                                                                                            function foldl

                                                                                            foldl: {
                                                                                            <A, B>(f: (x: A) => (y: B) => A): (memo: A) => (xs: B[]) => A;
                                                                                            <A, B>(f: (x: A) => (y: B) => A, memo: A): (xs: B[]) => A;
                                                                                            <A, B>(f: (x: A) => (y: B) => A, memo: A, xs: B[]): A;
                                                                                            };

                                                                                              function foldl1

                                                                                              foldl1: {
                                                                                              <A>(f: (x: A) => (y: A) => A): (xs: A[]) => A;
                                                                                              <A>(f: (x: A) => (y: A) => A, xs: A[]): A;
                                                                                              };

                                                                                                function foldr

                                                                                                foldr: {
                                                                                                <A, B>(f: (x: A) => (y: B) => B): (memo: B) => (xs: A[]) => B;
                                                                                                <A, B>(f: (x: A) => (y: B) => B, memo: B): (xs: A[]) => B;
                                                                                                <A, B>(f: (x: A) => (y: B) => B, memo: B, xs: A[]): B;
                                                                                                };

                                                                                                  function foldr1

                                                                                                  foldr1: {
                                                                                                  <A>(f: (x: A) => (y: A) => A): (xs: A[]) => A;
                                                                                                  <A>(f: (x: A) => (y: A) => A, xs: A[]): A;
                                                                                                  };

                                                                                                    function gcd

                                                                                                    gcd: { (x: number): (y: number) => number; (x: number, y: number): number };

                                                                                                      function groupBy

                                                                                                      groupBy: {
                                                                                                      <A, B>(f: (x: A) => B): (xs: A[]) => any;
                                                                                                      <A, B>(f: (x: A) => B, xs: A[]): any;
                                                                                                      };
                                                                                                        head: <A>(xs: A[]) => A;

                                                                                                          function id

                                                                                                          id: <A>(x: A) => A;

                                                                                                            function initial

                                                                                                            initial: <A>(xs: A[]) => A[];

                                                                                                              function intersection

                                                                                                              intersection: <A>(...xss: A[][]) => A[];

                                                                                                                function isItNaN

                                                                                                                isItNaN: (x: number) => boolean;

                                                                                                                  function isType

                                                                                                                  isType: {
                                                                                                                  <A>(type: string): (x: A) => boolean;
                                                                                                                  <A>(type: string, x: A): boolean;
                                                                                                                  };

                                                                                                                    function join

                                                                                                                    join: {
                                                                                                                    (separator: string): (xs: string[]) => string;
                                                                                                                    (separator: string, xs: string[]): string;
                                                                                                                    };

                                                                                                                      function keys

                                                                                                                      keys: {
                                                                                                                      <A>(object: { [key: string]: A }): string[];
                                                                                                                      <A>(object: { [key: number]: A }): number[];
                                                                                                                      };

                                                                                                                        function last

                                                                                                                        last: <A>(xs: A[]) => A;

                                                                                                                          function lcm

                                                                                                                          lcm: { (x: number): (y: number) => number; (x: number, y: number): number };

                                                                                                                            function lines

                                                                                                                            lines: (str: string) => string[];

                                                                                                                              function listsToObj

                                                                                                                              listsToObj: {
                                                                                                                              <A>(keys: string[]): (values: A[]) => { [key: string]: A };
                                                                                                                              <A>(keys: string[], values: A[]): { [key: string]: A };
                                                                                                                              <A>(keys: number[]): (values: A[]) => { [key: number]: A };
                                                                                                                              <A>(keys: number[], values: A[]): { [key: number]: A };
                                                                                                                              };

                                                                                                                                function ln

                                                                                                                                ln: (x: number) => number;

                                                                                                                                  function map

                                                                                                                                  map: {
                                                                                                                                  <A, B>(f: (x: A) => B): (xs: A[]) => B[];
                                                                                                                                  <A, B>(f: (x: A) => B, xs: A[]): B[];
                                                                                                                                  <A, B>(f: (x: A) => B): (object: { [key: string]: A }) => { [key: string]: B };
                                                                                                                                  <A, B>(f: (x: A) => B, object: { [key: string]: A }): { [key: string]: B };
                                                                                                                                  <A, B>(f: (x: A) => B): (object: { [key: number]: A }) => { [key: number]: B };
                                                                                                                                  <A, B>(f: (x: A) => B, object: { [key: number]: A }): { [key: number]: B };
                                                                                                                                  };

                                                                                                                                    function max

                                                                                                                                    max: {
                                                                                                                                    <Comparable>(x: Comparable): (y: Comparable) => Comparable;
                                                                                                                                    <Comparable>(x: Comparable, y: Comparable): Comparable;
                                                                                                                                    };

                                                                                                                                      function maximum

                                                                                                                                      maximum: <A>(xs: A[]) => A;

                                                                                                                                        function maximumBy

                                                                                                                                        maximumBy: {
                                                                                                                                        <A, B>(f: (x: A) => B): (xs: A[]) => A;
                                                                                                                                        <A, B>(f: (x: A) => B, xs: A[]): A;
                                                                                                                                        };

                                                                                                                                          function mean

                                                                                                                                          mean: (xs: number[]) => number;

                                                                                                                                            function min

                                                                                                                                            min: {
                                                                                                                                            <Comparable>(x: Comparable): (y: Comparable) => Comparable;
                                                                                                                                            <Comparable>(x: Comparable, y: Comparable): Comparable;
                                                                                                                                            };

                                                                                                                                              function minimum

                                                                                                                                              minimum: <A>(xs: A[]) => A;

                                                                                                                                                function minimumBy

                                                                                                                                                minimumBy: {
                                                                                                                                                <A, B>(f: (x: A) => B): (xs: A[]) => A;
                                                                                                                                                <A, B>(f: (x: A) => B, xs: A[]): A;
                                                                                                                                                };

                                                                                                                                                  function mod

                                                                                                                                                  mod: { (x: number): (y: number) => number; (x: number, y: number): number };

                                                                                                                                                    function negate

                                                                                                                                                    negate: (x: number) => number;

                                                                                                                                                      function objToLists

                                                                                                                                                      objToLists: {
                                                                                                                                                      <A>(object: { [key: string]: A }): [string[], A[]];
                                                                                                                                                      <A>(object: { [key: number]: A }): [number[], A[]];
                                                                                                                                                      };

                                                                                                                                                        function objToPairs

                                                                                                                                                        objToPairs: {
                                                                                                                                                        <A>(object: { [key: string]: A }): [string, A][];
                                                                                                                                                        <A>(object: { [key: number]: A }): [number, A][];
                                                                                                                                                        };

                                                                                                                                                          function odd

                                                                                                                                                          odd: (x: number) => boolean;

                                                                                                                                                            function orList

                                                                                                                                                            orList: <A>(xs: A[]) => boolean;

                                                                                                                                                              function over

                                                                                                                                                              over: {
                                                                                                                                                              <A, B, C>(
                                                                                                                                                              f: (x: B) => (y: B) => C | ((x: B, y: B) => C),
                                                                                                                                                              g: (x: A) => B,
                                                                                                                                                              x: A,
                                                                                                                                                              y: A
                                                                                                                                                              ): C;
                                                                                                                                                              <A, B, C>(
                                                                                                                                                              f: (x: B, y: B) => C | ((x: B) => (y: B) => C),
                                                                                                                                                              g: (x: A) => B,
                                                                                                                                                              x: A
                                                                                                                                                              ): (y: A) => C;
                                                                                                                                                              <A, B, C>(f: (x: B, y: B) => C, g: (x: A) => B): (x: A, y: A) => C;
                                                                                                                                                              <A, B, C>(f: (x: B) => (y: B) => C, g: (x: A) => B): (x: A) => (y: A) => C;
                                                                                                                                                              <A, B, C>(f: (x: B, y: B) => C): (g: (x: A) => B) => (x: A, y: A) => C;
                                                                                                                                                              <A, B, C>(f: (x: B) => (y: B) => C): (g: (x: A) => B) => (x: A) => (y: A) => C;
                                                                                                                                                              };

                                                                                                                                                                function pairsToObj

                                                                                                                                                                pairsToObj: {
                                                                                                                                                                <A>(object: [string, A][]): { [key: string]: A };
                                                                                                                                                                <A>(object: [number, A][]): { [key: number]: A };
                                                                                                                                                                };

                                                                                                                                                                  function partition

                                                                                                                                                                  partition: {
                                                                                                                                                                  <A>(f: (x: A) => Boolean): (xs: A[]) => [A[], A[]];
                                                                                                                                                                  <A>(f: (x: A) => Boolean, xs: A[]): [A[], A[]];
                                                                                                                                                                  <A>(f: (x: A) => boolean): (object: {
                                                                                                                                                                  [key: string]: A;
                                                                                                                                                                  }) => [{ [key: string]: A }, { [key: string]: A }];
                                                                                                                                                                  <A>(f: (x: A) => boolean, object: { [key: string]: A }): [
                                                                                                                                                                  { [key: string]: A },
                                                                                                                                                                  { [key: string]: A }
                                                                                                                                                                  ];
                                                                                                                                                                  <A>(f: (x: A) => boolean): (object: {
                                                                                                                                                                  [key: number]: A;
                                                                                                                                                                  }) => [{ [key: number]: A }, { [key: number]: A }];
                                                                                                                                                                  <A>(f: (x: A) => boolean, object: { [key: number]: A }): [
                                                                                                                                                                  { [key: number]: A },
                                                                                                                                                                  { [key: number]: A }
                                                                                                                                                                  ];
                                                                                                                                                                  };

                                                                                                                                                                    function pow

                                                                                                                                                                    pow: { (x: number): (y: number) => number; (x: number, y: number): number };

                                                                                                                                                                      function product

                                                                                                                                                                      product: (xs: number[]) => number;

                                                                                                                                                                        function quot

                                                                                                                                                                        quot: { (x: number): (y: number) => number; (x: number, y: number): number };

                                                                                                                                                                          function recip

                                                                                                                                                                          recip: (x: number) => number;

                                                                                                                                                                            function reject

                                                                                                                                                                            reject: {
                                                                                                                                                                            <A>(f: (x: A) => boolean): (xs: A[]) => A[];
                                                                                                                                                                            <A>(f: (x: A) => boolean, xs: A[]): A[];
                                                                                                                                                                            <A>(f: (x: A) => boolean): (object: {
                                                                                                                                                                            [key: string]: A;
                                                                                                                                                                            }) => { [key: string]: A };
                                                                                                                                                                            <A>(f: (x: A) => boolean, object: { [key: string]: A }): { [key: string]: A };
                                                                                                                                                                            <A>(f: (x: A) => boolean): (object: {
                                                                                                                                                                            [key: number]: A;
                                                                                                                                                                            }) => { [key: number]: A };
                                                                                                                                                                            <A>(f: (x: A) => boolean, object: { [key: number]: A }): { [key: number]: A };
                                                                                                                                                                            };

                                                                                                                                                                              function rem

                                                                                                                                                                              rem: { (x: number): (y: number) => number; (x: number, y: number): number };

                                                                                                                                                                                function repeat

                                                                                                                                                                                repeat: {
                                                                                                                                                                                (n: number): (str: string) => string;
                                                                                                                                                                                (n: number, str: string): string;
                                                                                                                                                                                };

                                                                                                                                                                                  function replicate

                                                                                                                                                                                  replicate: { <A>(n: number): (x: A) => A[]; <A>(n: number, x: A): A[] };

                                                                                                                                                                                    function reverse

                                                                                                                                                                                    reverse: { <A>(xs: A[]): A[]; (str: string): string };

                                                                                                                                                                                      function round

                                                                                                                                                                                      round: (x: number) => number;

                                                                                                                                                                                        function scan

                                                                                                                                                                                        scan: {
                                                                                                                                                                                        <A, B>(f: (x: A) => (y: B) => A): (memo: A) => (xs: B[]) => A[];
                                                                                                                                                                                        <A, B>(f: (x: A) => (y: B) => A, memo: A): (xs: B[]) => A[];
                                                                                                                                                                                        <A, B>(f: (x: A) => (y: B) => A, memo: A, xs: B[]): A[];
                                                                                                                                                                                        };

                                                                                                                                                                                          function scan1

                                                                                                                                                                                          scan1: {
                                                                                                                                                                                          <A>(f: (x: A) => (y: A) => A): (xs: A[]) => A[];
                                                                                                                                                                                          <A>(f: (x: A) => (y: A) => A, xs: A[]): A[];
                                                                                                                                                                                          };

                                                                                                                                                                                            function scanl

                                                                                                                                                                                            scanl: {
                                                                                                                                                                                            <A, B>(f: (x: A) => (y: B) => A): (memo: A) => (xs: B[]) => A[];
                                                                                                                                                                                            <A, B>(f: (x: A) => (y: B) => A, memo: A): (xs: B[]) => A[];
                                                                                                                                                                                            <A, B>(f: (x: A) => (y: B) => A, memo: A, xs: B[]): A[];
                                                                                                                                                                                            };

                                                                                                                                                                                              function scanl1

                                                                                                                                                                                              scanl1: {
                                                                                                                                                                                              <A>(f: (x: A) => (y: A) => A): (xs: A[]) => A[];
                                                                                                                                                                                              <A>(f: (x: A) => (y: A) => A, xs: A[]): A[];
                                                                                                                                                                                              };

                                                                                                                                                                                                function scanr

                                                                                                                                                                                                scanr: {
                                                                                                                                                                                                <A, B>(f: (x: A) => (y: B) => B): (memo: B) => (xs: A[]) => B[];
                                                                                                                                                                                                <A, B>(f: (x: A) => (y: B) => B, memo: B): (xs: A[]) => B[];
                                                                                                                                                                                                <A, B>(f: (x: A) => (y: B) => B, memo: B, xs: A[]): B[];
                                                                                                                                                                                                };

                                                                                                                                                                                                  function scanr1

                                                                                                                                                                                                  scanr1: {
                                                                                                                                                                                                  <A>(f: (x: A) => (y: A) => A): (xs: A[]) => A[];
                                                                                                                                                                                                  <A>(f: (x: A) => (y: A) => A, xs: A[]): A[];
                                                                                                                                                                                                  };

                                                                                                                                                                                                    function signum

                                                                                                                                                                                                    signum: (x: number) => number;

                                                                                                                                                                                                      function sin

                                                                                                                                                                                                      sin: (x: number) => number;

                                                                                                                                                                                                        function slice

                                                                                                                                                                                                        slice: {
                                                                                                                                                                                                        <A>(x: number): (y: number) => (xs: A[]) => A[];
                                                                                                                                                                                                        <A>(x: number, y: number): (xs: A[]) => A[];
                                                                                                                                                                                                        <A>(x: number, y: number, xs: A[]): A[];
                                                                                                                                                                                                        (x: number): (y: number) => (str: string) => string;
                                                                                                                                                                                                        (x: number, y: number): (str: string) => string;
                                                                                                                                                                                                        (x: number, y: number, str: string): string;
                                                                                                                                                                                                        };

                                                                                                                                                                                                          function sort

                                                                                                                                                                                                          sort: <A>(xs: A[]) => A[];

                                                                                                                                                                                                            function sortBy

                                                                                                                                                                                                            sortBy: {
                                                                                                                                                                                                            <A, B>(f: (x: A) => B): (xs: A[]) => A[];
                                                                                                                                                                                                            <A, B>(f: (x: A) => B, xs: A[]): A[];
                                                                                                                                                                                                            };

                                                                                                                                                                                                              function sortWith

                                                                                                                                                                                                              sortWith: {
                                                                                                                                                                                                              <A>(f: (x: A) => (y: A) => number): (xs: A[]) => A[];
                                                                                                                                                                                                              <A>(f: (x: A) => (y: A) => number, xs: A[]): A[];
                                                                                                                                                                                                              };

                                                                                                                                                                                                                function span

                                                                                                                                                                                                                span: {
                                                                                                                                                                                                                <A>(p: (x: A) => boolean): (xs: A[]) => [A[], A[]];
                                                                                                                                                                                                                <A>(p: (x: A) => boolean, xs: A[]): [A[], A[]];
                                                                                                                                                                                                                (f: (str: string) => boolean): (str: string) => [string, string];
                                                                                                                                                                                                                (f: (str: string) => boolean, str: string): [string, string];
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  function split

                                                                                                                                                                                                                  split: {
                                                                                                                                                                                                                  (separator: string): (str: string) => string[];
                                                                                                                                                                                                                  (separator: string, str: string): string[];
                                                                                                                                                                                                                  };

                                                                                                                                                                                                                    function splitAt

                                                                                                                                                                                                                    splitAt: {
                                                                                                                                                                                                                    <A>(n: number): (xs: A[]) => [A[], A[]];
                                                                                                                                                                                                                    <A>(n: number, xs: A[]): [A[], A[]];
                                                                                                                                                                                                                    (n: number): (str: string) => [string, string];
                                                                                                                                                                                                                    (n: number, str: string): [string, string];
                                                                                                                                                                                                                    };

                                                                                                                                                                                                                      function sqrt

                                                                                                                                                                                                                      sqrt: (x: number) => number;

                                                                                                                                                                                                                        function sum

                                                                                                                                                                                                                        sum: (xs: number[]) => number;

                                                                                                                                                                                                                          function tail

                                                                                                                                                                                                                          tail: <A>(xs: A[]) => A[];

                                                                                                                                                                                                                            function take

                                                                                                                                                                                                                            take: {
                                                                                                                                                                                                                            <A>(n: number): (xs: A[]) => A[];
                                                                                                                                                                                                                            <A>(n: number, xs: A[]): A[];
                                                                                                                                                                                                                            (n: number): (str: string) => string;
                                                                                                                                                                                                                            (n: number, str: string): string;
                                                                                                                                                                                                                            };

                                                                                                                                                                                                                              function takeWhile

                                                                                                                                                                                                                              takeWhile: {
                                                                                                                                                                                                                              <A>(p: (x: A) => boolean): (xs: A[]) => A[];
                                                                                                                                                                                                                              <A>(p: (x: A) => boolean, xs: A[]): A[];
                                                                                                                                                                                                                              (f: (str: string) => boolean): (str: string) => string;
                                                                                                                                                                                                                              (f: (str: string) => boolean, str: string): string;
                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                function tan

                                                                                                                                                                                                                                tan: (x: number) => number;

                                                                                                                                                                                                                                  function truncate

                                                                                                                                                                                                                                  truncate: (x: number) => number;

                                                                                                                                                                                                                                    function unchars

                                                                                                                                                                                                                                    unchars: (xs: string[]) => string;

                                                                                                                                                                                                                                      function unfoldr

                                                                                                                                                                                                                                      unfoldr: {
                                                                                                                                                                                                                                      <A, B>(f: (x: B) => [A, B] | void): (x: B) => A[];
                                                                                                                                                                                                                                      <A, B>(f: (x: B) => void | [A, B], x: B): A[];
                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                        function union

                                                                                                                                                                                                                                        union: <A>(...xss: A[][]) => A[];

                                                                                                                                                                                                                                          function unique

                                                                                                                                                                                                                                          unique: <A>(xs: A[]) => A[];

                                                                                                                                                                                                                                            function uniqueBy

                                                                                                                                                                                                                                            uniqueBy: {
                                                                                                                                                                                                                                            <A, B>(f: (x: A) => B): (xs: A[]) => A[];
                                                                                                                                                                                                                                            <A, B>(f: (x: A) => B, xs: A[]): A[];
                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                              function unlines

                                                                                                                                                                                                                                              unlines: (xs: string[]) => string;

                                                                                                                                                                                                                                                function unwords

                                                                                                                                                                                                                                                unwords: (xs: string[]) => string;

                                                                                                                                                                                                                                                  function values

                                                                                                                                                                                                                                                  values: {
                                                                                                                                                                                                                                                  <A>(object: { [key: string]: A }): A[];
                                                                                                                                                                                                                                                  <A>(object: { [key: number]: A }): A[];
                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                    function words

                                                                                                                                                                                                                                                    words: (str: string) => string[];

                                                                                                                                                                                                                                                      function zip

                                                                                                                                                                                                                                                      zip: {
                                                                                                                                                                                                                                                      <A, B>(xs: A[]): (ys: B[]) => [A, B][];
                                                                                                                                                                                                                                                      <A, B>(xs: A[], ys: B[]): [A, B][];
                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                        function zipAll

                                                                                                                                                                                                                                                        zipAll: <A>(...xss: A[][]) => A[][];

                                                                                                                                                                                                                                                          function zipAllWith

                                                                                                                                                                                                                                                          zipAllWith: <A, B>(f: (...xs: A[]) => B, ...xss: A[][]) => B[];

                                                                                                                                                                                                                                                            function zipWith

                                                                                                                                                                                                                                                            zipWith: {
                                                                                                                                                                                                                                                            <A, B, C>(f: (x: A) => (y: B) => C): (xs: A[]) => (ys: B[]) => C[];
                                                                                                                                                                                                                                                            <A, B, C>(f: (x: A) => (y: B) => C, xs: A[]): (ys: B[]) => C[];
                                                                                                                                                                                                                                                            <A, B, C>(f: (x: A) => (y: B) => C, xs: A[], ys: B[]): C[];
                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                              Namespaces

                                                                                                                                                                                                                                                              namespace Obj

                                                                                                                                                                                                                                                              namespace Obj {}

                                                                                                                                                                                                                                                                function compact

                                                                                                                                                                                                                                                                compact: {
                                                                                                                                                                                                                                                                <A>(object: { [key: string]: A }): { [key: string]: A };
                                                                                                                                                                                                                                                                <A>(object: { [key: number]: A }): { [key: number]: A };
                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                  function each

                                                                                                                                                                                                                                                                  each: {
                                                                                                                                                                                                                                                                  <A>(f: (x: A) => void): (object: { [key: string]: A }) => { [key: string]: A };
                                                                                                                                                                                                                                                                  <A>(f: (x: A) => void, object: { [key: string]: A }): { [key: string]: A };
                                                                                                                                                                                                                                                                  <A>(f: (x: A) => void): (object: { [key: number]: A }) => { [key: number]: A };
                                                                                                                                                                                                                                                                  <A>(f: (x: A) => void, object: { [key: number]: A }): { [key: number]: A };
                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                    function empty

                                                                                                                                                                                                                                                                    empty: <A>(object: any) => boolean;

                                                                                                                                                                                                                                                                      function filter

                                                                                                                                                                                                                                                                      filter: {
                                                                                                                                                                                                                                                                      <A>(f: (x: A) => boolean): (object: {
                                                                                                                                                                                                                                                                      [key: string]: A;
                                                                                                                                                                                                                                                                      }) => { [key: string]: A };
                                                                                                                                                                                                                                                                      <A>(f: (x: A) => boolean, object: { [key: string]: A }): { [key: string]: A };
                                                                                                                                                                                                                                                                      <A>(f: (x: A) => boolean): (object: {
                                                                                                                                                                                                                                                                      [key: number]: A;
                                                                                                                                                                                                                                                                      }) => { [key: number]: A };
                                                                                                                                                                                                                                                                      <A>(f: (x: A) => boolean, object: { [key: number]: A }): { [key: number]: A };
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        function find

                                                                                                                                                                                                                                                                        find: {
                                                                                                                                                                                                                                                                        <A>(f: (x: A) => boolean): (object: { [key: string]: A }) => A;
                                                                                                                                                                                                                                                                        <A>(f: (x: A) => boolean, object: { [key: string]: A }): A;
                                                                                                                                                                                                                                                                        <A>(f: (x: A) => boolean): (object: { [key: number]: A }) => A;
                                                                                                                                                                                                                                                                        <A>(f: (x: A) => boolean, object: { [key: number]: A }): A;
                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                          function map

                                                                                                                                                                                                                                                                          map: {
                                                                                                                                                                                                                                                                          <A, B>(f: (x: A) => B): (object: { [key: string]: A }) => { [key: string]: B };
                                                                                                                                                                                                                                                                          <A, B>(f: (x: A) => B, object: { [key: string]: A }): { [key: string]: B };
                                                                                                                                                                                                                                                                          <A, B>(f: (x: A) => B): (object: { [key: number]: A }) => { [key: number]: B };
                                                                                                                                                                                                                                                                          <A, B>(f: (x: A) => B, object: { [key: number]: A }): { [key: number]: B };
                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                            function partition

                                                                                                                                                                                                                                                                            partition: {
                                                                                                                                                                                                                                                                            <A>(f: (x: A) => boolean): (object: {
                                                                                                                                                                                                                                                                            [key: string]: A;
                                                                                                                                                                                                                                                                            }) => [{ [key: string]: A }, { [key: string]: A }];
                                                                                                                                                                                                                                                                            <A>(f: (x: A) => boolean, object: { [key: string]: A }): [
                                                                                                                                                                                                                                                                            { [key: string]: A },
                                                                                                                                                                                                                                                                            { [key: string]: A }
                                                                                                                                                                                                                                                                            ];
                                                                                                                                                                                                                                                                            <A>(f: (x: A) => boolean): (object: {
                                                                                                                                                                                                                                                                            [key: number]: A;
                                                                                                                                                                                                                                                                            }) => [{ [key: number]: A }, { [key: number]: A }];
                                                                                                                                                                                                                                                                            <A>(f: (x: A) => boolean, object: { [key: number]: A }): [
                                                                                                                                                                                                                                                                            { [key: number]: A },
                                                                                                                                                                                                                                                                            { [key: number]: A }
                                                                                                                                                                                                                                                                            ];
                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                              function reject

                                                                                                                                                                                                                                                                              reject: {
                                                                                                                                                                                                                                                                              <A>(f: (x: A) => boolean): (object: {
                                                                                                                                                                                                                                                                              [key: string]: A;
                                                                                                                                                                                                                                                                              }) => { [key: string]: A };
                                                                                                                                                                                                                                                                              <A>(f: (x: A) => boolean, object: { [key: string]: A }): { [key: string]: A };
                                                                                                                                                                                                                                                                              <A>(f: (x: A) => boolean): (object: {
                                                                                                                                                                                                                                                                              [key: number]: A;
                                                                                                                                                                                                                                                                              }) => { [key: number]: A };
                                                                                                                                                                                                                                                                              <A>(f: (x: A) => boolean, object: { [key: number]: A }): { [key: number]: A };
                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                namespace Str

                                                                                                                                                                                                                                                                                namespace Str {}

                                                                                                                                                                                                                                                                                  function breakStr

                                                                                                                                                                                                                                                                                  breakStr: {
                                                                                                                                                                                                                                                                                  (f: (str: string) => boolean): (str: string) => [string, string];
                                                                                                                                                                                                                                                                                  (f: (str: string) => boolean, str: string): [string, string];
                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                    function drop

                                                                                                                                                                                                                                                                                    drop: { (n: number): (str: string) => string; (n: number, str: string): string };

                                                                                                                                                                                                                                                                                      function dropWhile

                                                                                                                                                                                                                                                                                      dropWhile: {
                                                                                                                                                                                                                                                                                      (f: (str: string) => boolean): (str: string) => string;
                                                                                                                                                                                                                                                                                      (f: (str: string) => boolean, str: string): string;
                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                        function empty

                                                                                                                                                                                                                                                                                        empty: (str: string) => boolean;

                                                                                                                                                                                                                                                                                          function reverse

                                                                                                                                                                                                                                                                                          reverse: (str: string) => string;

                                                                                                                                                                                                                                                                                            function slice

                                                                                                                                                                                                                                                                                            slice: {
                                                                                                                                                                                                                                                                                            (x: number): (y: number) => (str: string) => string;
                                                                                                                                                                                                                                                                                            (x: number, y: number): (str: string) => string;
                                                                                                                                                                                                                                                                                            (x: number, y: number, str: string): string;
                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                              function span

                                                                                                                                                                                                                                                                                              span: {
                                                                                                                                                                                                                                                                                              (f: (str: string) => boolean): (str: string) => [string, string];
                                                                                                                                                                                                                                                                                              (f: (str: string) => boolean, str: string): [string, string];
                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                function splitAt

                                                                                                                                                                                                                                                                                                splitAt: {
                                                                                                                                                                                                                                                                                                (n: number): (str: string) => [string, string];
                                                                                                                                                                                                                                                                                                (n: number, str: string): [string, string];
                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                  function take

                                                                                                                                                                                                                                                                                                  take: { (n: number): (str: string) => string; (n: number, str: string): string };

                                                                                                                                                                                                                                                                                                    function takeWhile

                                                                                                                                                                                                                                                                                                    takeWhile: {
                                                                                                                                                                                                                                                                                                    (f: (str: string) => boolean): (str: string) => string;
                                                                                                                                                                                                                                                                                                    (f: (str: string) => boolean, str: string): string;
                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                      Package Files (1)

                                                                                                                                                                                                                                                                                                      Dependencies (0)

                                                                                                                                                                                                                                                                                                      No dependencies.

                                                                                                                                                                                                                                                                                                      Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                      No dev dependencies.

                                                                                                                                                                                                                                                                                                      Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                      No peer dependencies.

                                                                                                                                                                                                                                                                                                      Badge

                                                                                                                                                                                                                                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/prelude-ls.

                                                                                                                                                                                                                                                                                                      • Markdown
                                                                                                                                                                                                                                                                                                        [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/prelude-ls)
                                                                                                                                                                                                                                                                                                      • HTML
                                                                                                                                                                                                                                                                                                        <a href="https://www.jsdocs.io/package/@types/prelude-ls"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>