osa1

// Code for the blog post: ...
// Tested with Koka 3.1.2.

import std/os/env
import std/os/file
import std/os/path

fun main()
  val args = get-args()
  val args-without-flags = args.remove(fn (arg) arg == "--test")

osa1

trait Sequence[seq, t, exn]:
    forEach(self: seq, consumer: Fn(t) / exn) / exn

# ------------------------------------------------------------------------------

type CountFrom:
    from: U32

impl Sequence[CountFrom, U32, exn]:
    forEach(self: CountFrom, consumer: Fn(U32) / exn) / exn:

osa1

Anonymous polymorphic variant (sum) types design

We need a type system that supports the use cases listed below.

Specifically I'm interested in making anonymous sums useful for error handling.

The syntax below are just an example. The final syntax will depend on the type system that will be used to support these use cases.

Also note that the language already has parametric polymorphism with constraints (i.e. typeclasses). The questions about subtyping vs. row poly. below are only for anonymous variants. Named types won't have subtyping.

osa1

-- An evaluator for the language "Untyped Arithmetic Expressions" described in
-- Types and Programming Langauges section 3.

-- Below I have a few different syntax for starting indentation blocks.
--
-- I'm looking for the syntax that is (in priority order)
--
--   (1) Most readable (subjective, I know)
--   (2) Easiest to implement tooling for (e.g. indentatation plugin in text
--       editors)

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: