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

eernstg

void main() {
  AnimatedContainer(
    SizedBox(
      height: 57,
      Row([
        if (widget.icon != null)
          SizedBox(height: 29, width: 29, widget.icon),
        Expanded(
          Column([
            const SizedBox(height: 8.5),

eernstg

abstract class Person {
  String name;
  String address;
}

class DelegatorPerson implements Person {
  DelegateePerson delegatee;
  DelegatorPerson(this.delegatee);
  String get name => delegatee.name(this);
  set name(String value) => delegatee.nameSet(this, value);

eernstg

main() {
  new Dog().feed("some food");
}

abstract class Pet {
  void feed(String food);
  void pet();
}

class Dog = Pet with FeedableDog, PettableDog;

eernstg

This document may be obsolete, please double-check against the review containing the current version and, if it exists, the version in the SDK repository.

Feature: Evaluating integer literals as double values

Author: eernst@.

Version: 0.4 (2018-08-14).