docs: def make(cls, *args, **kwargs):
          """
          Configure and create a classifier that will consume data and produce
          classifications, given the configuration options specified by this
          function.
  
          Note that this like a *partial application* of the relevant class
          constructor. `make` creates a function that returns classifications; it
          does not actually do the classification.
  
          If you want to classify data directly, use the appropriate class
          constructor, like Quantiles, Max_Breaks, etc.
  
          If you *have* a classifier object, but want to find which bins new data
          falls into, use find_bin.
  
          Parameters
          ----------
          *args           : required positional arguments
                            all positional arguments required by the classifier,
                            excluding the input data.
          rolling         : bool
                            a boolean configuring the outputted classifier to use
                            a rolling classifier rather than a new classifier for
                            each input. If rolling, this adds the current data to
                            all of the previous data in the classifier, and
                            rebalances the bins, like a running median
                            computation.
          return_object   : bool
                            a boolean configuring the outputted classifier to
                            return the classifier object or not
          return_bins     : bool
                            a boolean configuring the outputted classifier to
                            return the bins/breaks or not
          return_counts   : bool
                            a boolean configuring the outputted classifier to
                            return the histogram of objects falling into each bin
                            or not
  
          Returns
          -------
          A function that consumes data and returns their bins (and object,
          bins/breaks, or counts, if requested).
  
          Note
          ----
          This is most useful when you want to run a classifier many times
          with a given configuration, such as when classifying many columns of an
          array or dataframe using the same configuration.
  
          Examples
          --------
          >>> import libpysal as ps
          >>> import mapclassify as mc
          >>> import geopandas as gpd
          >>> df = gpd.read_file(ps.examples.get_path('columbus.dbf'))
          >>> classifier = mc.Quantiles.make(k=9)
          >>> cl = df[['HOVAL', 'CRIME', 'INC']].apply(classifier)
          >>> cl["HOVAL"].values[:10]
          array([8, 7, 2, 4, 1, 3, 8, 5, 7, 8])
          >>> cl["CRIME"].values[:10]
          array([0, 1, 3, 4, 6, 2, 0, 5, 3, 4])
          >>> cl["INC"].values[:10]
          array([7, 8, 5, 0, 3, 5, 0, 3, 6, 4])
          >>> import pandas as pd; from numpy import linspace as lsp
          >>> data = [lsp(3,8,num=10), lsp(10, 0, num=10), lsp(-5, 15, num=10)]
          >>> data = pd.DataFrame(data).T
          >>> data
                    0          1          2
          0  3.000000  10.000000  -5.000000
          1  3.555556   8.888889  -2.777778
          2  4.111111   7.777778  -0.555556
          3  4.666667   6.666667   1.666667
          4  5.222222   5.555556   3.888889
          5  5.777778   4.444444   6.111111
          6  6.333333   3.333333   8.333333
          7  6.888889   2.222222  10.555556
          8  7.444444   1.111111  12.777778
          9  8.000000   0.000000  15.000000
          >>> data.apply(mc.Quantiles.make(rolling=True))
             0  1  2
          0  0  4  0
          1  0  4  0
          2  1  4  0
          3  1  3  0
          4  2  2  1
          5  2  1  2
          6  3  0  4
          7  3  0  4
          8  4  0  4
          9  4  0  4
          >>> dbf = ps.io.open(ps.examples.get_path('baltim.dbf'))
          >>> data = dbf.by_col_array('PRICE', 'LOTSZ', 'SQFT')
          >>> my_bins = [1, 10, 20, 40, 80]
          >>> cl = [mc.User_Defined.make(bins=my_bins)(a) for a in data.T]
          >>> len(cl)
          3
          >>> cl[0][:10]
          array([4, 5, 5, 5, 4, 4, 5, 4, 4, 5])
          """
  
          # only flag overrides return flag
          to_annotate = copy.deepcopy(kwargs)
          return_object = kwargs.pop('return_object', False)
          return_bins = kwargs.pop('return_bins', False)
          return_counts = kwargs.pop('return_counts', False)
  
          rolling = kwargs.pop('rolling', False)
          if rolling:
              #  just initialize a fake classifier
              data = list(range(10))
              cls_instance = cls(data, *args, **kwargs)
              #  and empty it, since we'll be using the update
              cls_instance.y = np.array([])
          else:
              cls_instance = None
  
          #  wrap init in a closure to make a consumer.
          #  Qc Na: "Objects/Closures are poor man's Closures/Objects"
          def classifier(data, cls_instance=cls_instance):
              if rolling:
                  cls_instance.update(data, inplace=True, **kwargs)
                  yb = cls_instance.find_bin(data)
              else:
                  cls_instance = cls(data, *args, **kwargs)
                  yb = cls_instance.yb
              outs = [yb, None, None, None]
              outs[1] = cls_instance if return_object else None
              outs[2] = cls_instance.bins if return_bins else None
              outs[3] = cls_instance.counts if return_counts else None
              outs = [a for a in outs if a is not None]
              if len(outs) == 1:
                  return outs[0]
              else:
                  return outs
  
          #  for debugging/jic, keep around the kwargs.
          #  in future, we might want to make this a thin class, so that we can
          #  set a custom repr. Call the class `Binner` or something, that's a
          #  pre-configured Classifier that just consumes data, bins it, &
          #  possibly updates the bins.
          classifier._options = to_annotate
          return classifier