/*
  getCompletionsForCompilerOptions(buffer,prefix,position)
  buffer: TextBuffer, current buffer
  prefix: String, completion prefix
  position: Point, current cursor position

  Returns: Promise([ghcopt])
  ghcopt: String, compiler option (starts with '-f')
  */
  public async getCompletionsForCompilerOptions(
    _buffer: TextBuffer, prefix: string, _position: Point,
  ): Promise<string[]> {
    if (!this.isActive) { throw new Error('Backend inactive') }
    const co: string[] = await this.process.backend.flags()
    return FZ.filter(co, prefix)
  }

  /*
  getCompletionsForLanguagePragmas(buffer,prefix,position)
  buffer: TextBuffer, current buffer
  prefix: String, completion prefix
  position: Point, current cursor position

  Returns: Promise([pragma])
  pragma: String, language option
  */
  public async getCompletionsForLanguagePragmas(
    _buffer: TextBuffer, prefix: string, _position: Point,
  ): Promise<string[]> {
    if (!this.isActive) { throw new Error('Backend inactive') }
    const ps: string[] = await this.process.backend.langs()
    return FZ.filter(ps, prefix)
  }

  /*
  getCompletionsForClass(buffer,prefix,position)
  buffer: TextBuffer, current buffer
  prefix: String, completion prefix
  position: Point, current cursor position

  Returns: Promise([symbol])
  symbol: Same as getCompletionsForSymbol, except
          symbolType is one of ['class']
  */
  public async getCompletionsForClass(
    buffer: TextBuffer, prefix: string, _position: Point,
  ): Promise<CB.ISymbol[]> {
    if (!this.isActive) { throw new Error('Backend inactive') }

    const symbols = await this.getCompletionsForBuffer(buffer, ['class'])
    return FZ.filter(symbols, prefix, { key: 'qname' })
  }

 private filterCompletions(
     completions: CompletionList, position: SourcePosition,
     document: Document): CompletionList {
   const leadingText = this.getLeadingIdentifier(position, document);
   const filterableCompletions = completions.items.map((completion) => {
     return {
       filterText: completion.filterText || completion.label,
       completion
     };
   });
   const items =
       fuzzaldrin
           .filter(filterableCompletions, leadingText, {key: 'filterText'})
           .map((i) => i.completion);
   return {isIncomplete: true, items};
 }

function createReportFromCompletionInfo(completionInfo: TSType.CompletionInfo, prefix: string): CodeHintsReport {
  let entries: TSType.CompletionEntry[] = completionInfo ? completionInfo.entries : [];

  if (prefix) {
    entries = fuzzaldrin.filter(entries, prefix, { key: 'name' });
  }

  entries = _.sortBy(entries, (entry: TSType.CompletionEntry) => {
    let sort = entry.sortText;
    if (prefix) {
      if (entry.name.indexOf(prefix) === 0) {
        // starts with prefix case sensitive
        sort += '0';
      } else if (entry.name.toLowerCase().indexOf(prefix.toLowerCase()) === 0) {
        // starts with prefix case in-sensitive
        sort += '1';
      } else {
        // other matches (fuzzy search)
        sort += '2';
      }
    }
    return sort + entry.name.toLowerCase();
  });

  const MAX_COMPLETIONS = 50;
  if (entries.length > MAX_COMPLETIONS) {
    entries = entries.slice(0, MAX_COMPLETIONS);
  }

  return {
    hints: entries.map((entry) => entry.name),
    match: prefix,
    selectInitial: true,
    handleWideResults: false
  };
}

 .map(s => filter(s, options.prefix, { key: '_search' }))

 .then(s => filter(s, search, { key: '_search' }));

import { match, filter, score } from 'fuzzaldrin';

let number = 0;
const string = '' as string;
let strings: string[] = [];
let objects: Array<{name: string, speed: number}> = [];

strings = filter(strings, string);
strings = filter(strings, string, {maxResults: number});
objects = filter(objects, string, {key: 'name'});
objects = filter(objects, string, {key: 'name', maxResults: number});

number = score(string, string);

match(string, string);

// These should be type errors! Uncomment to verify.
// objects = filter(objects, string);
// objects = filter(objects, string, {key: 'speed'});
// strings = filter(strings, string, {key: 'speed'});

 this.connection.onWorkspaceSymbol(async(params) => {
   const analysis =
       await this.analyzer.analyzePackage({reason: 'get workspace symbols'});
   const symbols = this.findSymbols(analysis);
   return fuzzaldrin.filter(symbols, params.query, {key: 'name'});
 });

 p = p.then(s => filter(s, search, { key: 'CompletionText' }));