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?

johnchandlerburnham

A Taxonomy of Self-Types

Part I: Introduction to Self-Types

Datatypes in the Formality programming language are built out of an unusual structure: the self-type. Roughly speaking, a self-type is a type that can depend or be a proposition on it's own value. For instance, the consider the 2 constructor datatype Bool:

FreyaHolmer

using UnityEngine;

[RequireComponent( typeof(Camera) )]
public class FlyCamera : MonoBehaviour {
	public float acceleration = 50; // how fast you accelerate
	public float accSprintMultiplier = 4; // how much faster you go when "sprinting"
	public float lookSensitivity = 1; // mouse look sensitivity
	public float dampingCoefficient = 5; // how quickly you break to a halt after you stop your input
	public bool focusOnEnable = true; // whether or not to focus and lock cursor immediately on enable

souenzzo

acutmore

A compile-time 4-Bit Virtual Machine implemented in TypeScript's type system. Capable of running a sample 'FizzBuzz' program.

Syntax emits zero JavaScript.

type RESULT = VM<
  [
    ["push", N_1],         // 1
    ["push", False],       // 2
 ["peek", _], // 3

sibelius

type Props = {
};
const FormUseFormik = (props: Props) => {
  const { enqueueSnackbar } = useSnackbar();

  const onSubmit = (values) => {
    enqueueSnackbar(`submit:  ${JSON.stringify(values)}`, {
      preventDuplicate: true,
      persist: false,
    });

simlrh

interface Composable<B,C> {
  (b: B): C;
  I: <D>(f: (c: C) => D) => Composable<B,D>;
  o: <A>(f: (a: A) => B) => Composable<A,C>;
}

/*
 * Non-type safe internal function - type safety of result is guaranteed by
 * allowing creation only through `I` and `o` functions and methods
 */

fvilante

import { mapObjIndexed } from 'ramda'


type PropMorphism
    <TKeyValue, TContext extends object, TKeyName, TResult> = 
    (value: TKeyValue, context: TContext, keyname: TKeyName) => 
        TResult

/**
 * Use HasExactlySameKeys if you want to assure to procced

IgorHalfeld

function createStore({ state, mutations }) {
  return {
    state: Vue.observable(state),
    commit(key, ...args) {
      mutations[key](state, ...args)
    }
  }
}
const store = createStore({
  state: { count: 0 },

sbrl

"use strict";

/**
 * Generates various VT100 ANSI escape sequences.
 * Ported from C#.
 * @licence MPL-2.0 <https://www.mozilla.org/en-US/MPL/2.0/>
 * @source https://gist.github.com/a4edd3204a03f4eedb79785751efb0f3#file-ansi-cs
 * @author Starbeamrainbowlabs
 * GitHub: @sbrl | Twitter: @SBRLabs | Reddit: u/Starbeamrainbowlabs
 ***** Changelog *****