References
| summary | ||
| public | 
       C Tape Class that wraps a callable with a tape.  | 
    |
| public | 
       C Chain  | 
    |
| public | 
       C Group  | 
    |
| private | 
       F asyncIterableChain(iterables: AsyncIterable<AsyncIterable>): AsyncIterable Utility function to chain an async iterable of async iterables.  | 
    |
| private | 
       F asyncIterableMap(callable: Function, iterable: AsyncIterable): AsyncIterable Utility function to apply a sync callable to each item of an async iterable.  | 
    |
| private | 
       F async * asyncIteratorMap(callable: Function, iterator: AsyncIterator): AsyncIterator Utility function to apply a sync callable to each item of an async iterator.  | 
    |
| public | 
      
       Converts a tape of tapes of tokens to a tape of tokens.  | 
    |
| public | 
      
       Exhausts a tape.  | 
    |
| public | 
       F fromAsyncIterable(_iterable: AsyncIterable): Tape Converts an asynchronous iterable to a tape.  | 
    |
| public | 
       F fromCallable(callable: Function): Tape Converts a callable to a tape.  | 
    |
| public | 
       F fromIterable(iterable: Iterable): Tape Converts an iterable to a tape.  | 
    |
| public | 
       F fromIterator(iterator: Iterator | AsyncIterator): Tape Converts an iterator to a tape.  | 
    |
| private | 
       F _fromReadStream(readStream: ReadStream): AsyncIterable Converts a ReadStream object to an async iterable of tokens.  | 
    |
| private | 
       F async * _fromReadStreamIterator(iterator: AsyncIterator): AsyncIterable Converts a ReadStream iterator to an async iterable of tokens.  | 
    |
| public | 
       F fromReadStream(readStream: ReadStream): Tape Converts a ReadStream object to a tape.  | 
    |
| public | 
      
       Filters a tape by ignoring a given set of tokens.  | 
    |
| public | 
      
       Applies a callable to each token of a tape.  | 
    |
| private | 
      
       Outputs the next token of a tape that is not contained in a given toskip set.  | 
    |
| private | 
      
       Same as split, but returns an iterable rather than a tape.  | 
    |
| public | 
      
       Splits the input tape into a tape of tapes according to some set of separators.  | 
    |
| public | 
      
       Converts a tape to an array.  | 
    |
| public | 
       F toAsyncCallable(tape: Tape): Function Converts a tape to a callable.  | 
    |
| public | 
       F async * toAsyncIterable(tape: Tape): AsyncIterable Converts a tape to an asynchronous iterable.  | 
    |
| public | 
       F toAsyncIterator(tape: Tape): AsyncIterator Converts a tape to an async iterator.  | 
    |
| public | 
      
       Converts a tape to a string.  | 
    |
| public | 
      
       Shared object used as end of file.  | 
    |
| public | 
      
       Converts an array to a tape.  | 
    |
| public | 
       V fromString(string: string): Tape: * Converts a string to a tape.  | 
    |
    
  