osa1

void main() {
  final List<int> list = [1, 2, 3];
  final List<num> otherList = list; // unsound, but Dart allows
  otherList.add(4.5); // unsoundness above requires runtime check here
}

osa1

# linkify.py input.md output.md github-username github-repo-name
#
# Converts PR, issue, and commit references to full links.
#
# Written by ChatGPT.

import re
import requests
import argparse

osa1

/*
Bad type inference causes breakage when making a type more precise in covariant
position.
*/

class A {
  const A();
}

const constA = const A();

osa1

use eframe::egui;

fn main() -> Result<(), eframe::Error> {
    let options = eframe::NativeOptions {
        drag_and_drop_support: true,
        initial_window_size: Some(egui::vec2(320.0, 240.0)),
        ..Default::default()
    };
    eframe::run_native(
        "Native file dialogs and drag-and-drop files",

osa1

import 'dart:typed_data';

void main() {
  final Int32List list = Int32List.fromList([1, 2, 3, 4, 5, 6]);

  // Create a view, list without the first and last elements.
  final Int32List view = Int32List.sublistView(list, 1, 5);
  print(view); // [2, 3, 4, 5, 6]

  // Do the same, this time using the `ByteBuffer` object.

osa1

/*
HM type inference with:

- Union-find for unification.
- Type variable levels for generalization.

Implementation became tricky because of the mutable level and link fields.

In this implementations links cannot form cycles (occurs check catches it), so we could use
`Rc<RefCell<..>>`-wrapped types.  However:

osa1

import 'my_library.dart';

// Same class B in Strange Dart 9.1, but this time it's accepted.
class B implements A {}

void main() {
  wat(B()); // _a getters and setters redirect to noSuchMethod
}

osa1

// Private members are not part of a class's interface, but implementing
// classes need to implement them.
//
// ... except when the class being implemented is in a separate library. See
// the second part: https://gist.github.com/osa1/a6b70f36d1041996c3ff7fa12c7589d8

class A {
  int _a = 1;
  int _b = 2;

osa1

class A {
  @override
  Type get runtimeType => int;
}

class B<T> {}

void main() {
  print(A().runtimeType); // int
  print(B<A>().runtimeType); // B<A>

osa1

// Almost by definition, if I'm able to pass X where Y is expected, then X is a
// subtype of Y.
//
// In Dart, this mostly holds, but `dynamic` is an exception. I can pass
// `dynamic` everywhere, but it's not really a subtype of anything.

void f(int a) {}

class C<A> {}