PlumpMath

Method for Emulating Higher-Kinded Types in Rust

Intro

I've been fiddling about with an idea lately, looking at how higher-kinded types can be represented in such a way that we can reason with them in Rust here and now, without having to wait a couple years for what would be a significant change to the language and compiler.

There have been multiple discussions on introducing higher-ranked polymorphism into Rust, using Haskell-style Higher-Kinded Types (HKTs) or Scala-looking Generalised Associated Types (GATs). The benefit of higher-ranked polymorphism is to allow higher-level, richer abstractions and pattern expression than just the rank-1 polymorphism we have today.

As an example, currently we can express this type:

graninas

At the beginning of 2030, I found this essay in my archives. From what I know today, I think it was very insightful at the moment of writing. And I feel it should be published because it can teach us, Rust developers, how to prevent that sad story from happening again.

---

What killed Haskell, could kill Rust, too

What killed Haskell, could kill Rust, too. Why would I even mention Haskell in this context? Well, Haskell and Rust are deeply related. Not because Rust is Haskell without HKTs. (Some of you know what that means, and the rest of you will wonder for a very long time). Much of the style of Rust is similar in many ways to the style of Haskell. In some sense Rust is a reincarnation of Haskell, with a little bit of C-ish like syntax, a very small amount.

Is Haskell dead?

ubolonton

(defvar bootstrap-version)
(let ((bootstrap-file
       (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
      (bootstrap-version 5))
  (unless (file-exists-p bootstrap-file)
    (with-current-buffer
        (url-retrieve-synchronously
         "https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el"
         'silent 'inhibit-cookies)
      (goto-char (point-max))

wavejumper

React Native + macOS + Clojurescript

Project Catalyst

Since the recent release of Catalina, macOS has shipped with the ability to allow iOS/iPAD apps to run on macOS without any modification via a featureset known as Project Catalyst.

This is exciting, as writing React Native + Clojurescript apps as a target for the desktop is much more compelling than a pure Electron app (imo).

louispan

# install nix (5.5 mins)
curl https://nixos.org/nix/install | sh

# open a new shell to source nix
bash

# query available haskell compilers
nix-env -qaP -A nixpkgs.haskell.compiler [QUERY]

# install ghc (2.5 mins, cached binary)

yogthos

(ns gjs-example.core)

(defn main []
  (set! (-> js/imports .-gi .-versions .-Gtk) "3.0")
  (let [Gtk (doto (-> js/imports .-gi .-Gtk) (.init nil))
        window (Gtk.Window.
                (clj->js
                 {:type (-> Gtk .-WindowType .-TOPLEVEL)
                  :title "A default title"
                  :default_width 300

edmundsmith

Method for Emulating Higher-Kinded Types in Rust

Intro

I've been fiddling about with an idea lately, looking at how higher-kinded types can be represented in such a way that we can reason with them in Rust here and now, without having to wait a couple years for what would be a significant change to the language and compiler.

There have been multiple discussions on introducing higher-ranked polymorphism into Rust, using Haskell-style Higher-Kinded Types (HKTs) or Scala-looking Generalised Associated Types (GATs). The benefit of higher-ranked polymorphism is to allow higher-level, richer abstractions and pattern expression than just the rank-1 polymorphism we have today.

As an example, currently we can express this type:

joinr

(defn children [item coll]
  (-> (filter #(= (:parent %) (:id item)) coll)
      seq))

(defn item-children 
  ([get-children item coll] 
   (if-let [xs  (get-children item coll)]
     (map #(lazy-seq (cons item  (item-children get-children % coll))) xs)
     (list [item nil])))
  ([item coll] (item-children (memoize children) item coll)))

dnaeon

;;
;; Making a deeply nested map by following parent-child relations between items
;;

(defn make-items [n]
  (concat [{:id 0 :name "item-root"}]
        (for [x (range 1 n)] {:id x :parent (dec x) :item (format "item-%d" x)})))

(defn item-children [item coll]
  (if-let [children (-> (filter #(= (:parent %) (:id item)) coll) seq)]

jb55

{ stdenv, lib, bash, callPackage, writeText, makeWrapper, writeScript, dotnet-sdk,
  patchelf, libunwind, coreclr, libuuid, curl, zlib, icu }:

let
  config = "Staging";
  project = "RazorCx.Api";
  target = "linux-x64";

  rpath = stdenv.lib.makeLibraryPath [ libunwind coreclr libuuid stdenv.cc.cc curl zlib icu ];