eernstg

import 'dart:async';

typedef Inv<X> = X Function(X);
typedef BetterCompleter<X> = _BetterCompleter<X, Inv<X>>;

extension type _BetterCompleter<X, Invariance extends Inv<X>>
    .fromCompleter(Completer<X> _) {
  void complete(X value) => _.complete(value);
  void completeError(Object error, [StackTrace? stackTrace]) =>
      _.completeError(error, stackTrace);

eernstg

dev/conductor/core/test/common.dart:79:11
  `String? name;` could just as well be `final String? name;`
dev/conductor/core/test/common.dart:82:15
  `command` could just as well be `final`
dev/conductor/core/test/common.dart:88:20
  Could return `const <String>[]`.
examples/layers/rendering/src/binding.dart:39:18
  Could be `late final RenderView _renderView;``
packages/flutter/lib/src/cupertino/route.dart:391:12
  `_page` can be stable if `settings` is stable

eernstg

class A<X extends A<X>> {}
class B extends A<B> {}
class C extends B {}

void f<X extends A<X>>(X x) {}

void main() {
  f<B>(C()); // OK.
  f(C()); // Compile-time error: "Couldn't infer ..".
}

eernstg

import 'package:http/http.dart' as http;
import 'dart:convert';

main() async {
  const pubUrl = "https://pub.dartlang.org/api/packages/protobuf";
  var response = await http.get(Uri.parse(Uri.encodeFull(pubUrl)));
  if (response.statusCode == 200) {
    PkgInfo info = PkgInfo(json.decode(response.body));
    print('Package ${info.name}, v ${info.latest.pubspec.version}');
  } else {

eernstg

import 'package:http/http.dart' as http;
import 'dart:convert';

main() async {
  const pubUrl = "https://pub.dartlang.org/api/packages/protobuf";
  var response = await http.get(Uri.parse(Uri.encodeFull(pubUrl)));
  if (response.statusCode == 200) {
    PkgInfo info = PkgInfo(json.decode(response.body));
    print('Package ${info.name}, v ${info.latest.pubspec.version}');
  } else {

eernstg

// Some code in this file depends on the 'link-time sets and maps' feature,
// cf. https://github.com/dart-lang/language/issues/371. The basic idea is that
// a link-time set/map can be declared in one library L, and any library L1 that
// imports L can contain contributions to said set/map (you can do `add` on a
// `Set` and `[]=` on a `Map`), and those operations occur before run time.
// For each of the contributions (`add` or `[]=` on a link time collection), the
// operation can be made conditional on the existence of some other entity (or,
// in general, on a boolean expression whose basic predicates is those entities).
// For instance, we could have `myLinkTimeSet.add(5) if C;`, which means that `5`
// will be added to `myLinkTimeSet` if and only if the class `C` is still contained

eernstg

enum Key {
  key1,
  key2;
    
  T mapFor<T>({
    required T Function() key1,
    required T Function() key2,
  }) {
    switch (this) {
      case Key.key1: return key1();

eernstg

// ----------------------------------------------------------------------
// Basic example, hypothetical code only.

// typeclass Index<inout X, in Y> {
//   X X.operator [](Y y);
// }

// instance Index<int, int> {
//   int int.operator [](int y) => this + y;
// }

eernstg

// define an example struct, make it printable
#[derive(Debug)]
struct Foo;

// an example trait
trait Bar {
    fn baz(&self);
}

// implement the trait for Foo

eernstg

/*
   Several examples, separated by '-----' lines.
   
   We probably want to use a regular type variable declaration list plus
   a constraint specification list (to request a dispatcher object for a
   specific typeclass instance), so I'm using `where` clauses in various
   headers.

   Dispatcher objects are holders of functions, and there is no particular
   notion of a receiver, so we're likely to benefit _greatly_ from sound