Using `(params -> return)` syntax.

function_types2.dart

// Uses in typedefs.

typedef CompilerInputProvider = (Uri -> Future/*<String | List<int>>*/);

typedef ReadStringFromUri = (Uri -> Future<String>);

typedef CompilerOutputProvider = (String name, String extension -> EventSink<String>);

typedef DiagnosticHandler =
    (Uri, int begin, int end, String message, Diagnostic kind -> void);

typedef PackagesDiscoveryProvider = (Uri -> Future<Packages>);

// Uses in parameters and fields.

class _DeferredAction {
  final Element element;
  final (-> void) action;

  _DeferredAction(this.element, this.action);
}

/// If [DEBUG_PRINT_ENABLED] is `true` print [s] using the current identation.
(dynamic s -> void) get debugPrint {
  enableDebugMode();
  // TODO(johnniwinther): Maybe disable debug mode after the call.
  return _debugPrint;
}

/// Use this to get a tree-like debug printout for nested calls.
(dynamic s, (-> dynamic) f -> dynamic) get debugWrapPrint {
  enableDebugMode();
  return _debugWrapPrint;
}

/// Print a message with a source location.
(DiagnosticReporter, Spannable node, String debugMessage -> dynamic)
    get reportHere {
  enableDebugMode();
  return _reportHere;
}

(String message, {(String stackTrace -> bool) condition, int limit,
    bool throwOnPrint} -> void)
get trace {
  enableDebugMode();
  return _trace;
}

void _trace(String message,
    {(String stackTrace -> bool) condition, int limit,
    bool throwOnPrint: false}) {
  ...
}

/// Implementation of [traceAndReport].
void _traceAndReport(
    DiagnosticReporter reporter, Spannable node, String message,
    {(String stackTrace -> bool) condition, int limit,
    bool throwOnPrint: false}) {
  trace(message, limit: limit, throwOnPrint: throwOnPrint,
      condition: (String stackTrace) {
    ...
  });
}

void emitNoSuchMethodHandlers(
    (jsAst.Name, jsAst.Expression -> jsAst.Property) addProperty) {
  ClassStubGenerator generator =
      new ClassStubGenerator(compiler, namer, backend);
  ...
}

void _generateIsTestsOn(
    ClassElement cls,
    (Element -> void) generateIsTest,
    (Element method, FunctionType methodType -> void)
        generateFunctionTypeSignature,
    (Element, {bool emitNull} -> void) generateSubstitution,
    void emitTypeCheck(TypeCheck check)) {
  Setlet<Element> generated = new Setlet<Element>();
  ...
}

void _generateInterfacesIsTests(
    ClassElement cls,
    (ClassElement -> void) generateIsTest,
    (Element, {bool emitNull} -> void) generateSubstitution,
    Set<Element> alreadyGenerated) {
  ...
}

/// Similar to [resetAsync] but [reuseLibrary] maps all libraries to a list
/// of libraries that can be reused.
Future<Null> resetLibraries(
    (Iterable<LibraryElement> -> Future<Iterable<LibraryElement>>)
      reuseLibraries);