zohnannor

## gist:d41c3ae485d66c07178749eaeeb9e5f7

      
              1 file
            
          
              2 forks
            
          
              4 comments
            
          
              69 stars
            
          
                brendanzab
                / gist:d41c3ae485d66c07178749eaeeb9e5f7
            
            
              Last active
              July 19, 2023 04:28
            
              
                My personal list of Rust grievances (September 2021)
              
          
September 2022:
This has spread to a far wider audience than I had anticipated - probably my fault for using a title that is in hindsight catnip for link aggregators. I wrote this back in 2021 just as a bunch of personal thoughts of my experiences using Rust over the years (not always well thought through), and don't intend on trying to push them further, outside of personal experiments and projects.
Managing a living language is challenging and difficult work, and I am grateful for all the hard work that the Rust community and contributors put in given the difficult constraints they work within. Many of the things I listed below are not new, and there's been plenty of difficult discussions about many of them over the years, and some are being worked on or postponed, or rejected for various good reasons. For more thoughts, please see my comment below.

My personal list of Rust gr


## rust1plus1.md

      
              1 file
            
          
              2 forks
            
          
              0 comments
            
          
              7 stars
            
          
                gretingz
                / rust1plus1.md
            
            
              Created
              June 26, 2021 14:07
            
              
                Proving that 1 + 1 = 2 in Rust
              
          
    Proving that 1 + 1 = 2 in Rust

The fact that 1 + 1 is equal to 2 is one of those things that is so obvious it may be hard to justify why.
Fortunately mathematicians have devised a way of formalizing arithmetic and subsequently proving that 1 + 1 = 2.
Natural numbers are based on the Peano axioms. They are a set of simple rules that define (along with a formal system) what natural numbers are. So in order to prove 1 + 1 = 2 in Rust we first need a formal system capable of handling logic. The formal system that we'll be using is not some random crate, but Rust's type system itself! We will not have any runtime code, instead the type checker will do all the work for us.
Implementing the Peano axioms

First let's go trough the Peano axioms. The first axiom is that "Zero is a natural number". Basically what it says is that zero exists. In order to express that in the type system, we just write:


## .vimrc
call plug#begin()
Plug 'drewtempelmeyer/palenight.vim'
Plug 'vim-airline/vim-airline'
Plug 'wlangstroth/vim-racket'
Plug 'sheerun/vim-polyglot'
Plug 'rust-lang/rust.vim'
Plug 'preservim/tagbar'
Plug 'universal-ctags/ctags'
Plug 'luochen1990/rainbow'
Plug 'vim-syntastic/syntastic'

## py_result.py
from typing import Generic, Optional, TypeVar
from abc import ABC, abstractmethod
from dataclasses import dataclass

T = TypeVar('T')
E = TypeVar('E')


class Result(Generic[T, E], ABC):
    @abstractmethod

## flappy.html
<body onload=z=c.getContext`2d`,setInterval(`c.width=W=150,Y<W&&P<Y&Y<P+E|9<p?z.fillText(S++${Y=`,9,9|z.fillRect(p`}*0,Y-=--M${Y+Y},P+E,9,W),P))):p=M=Y=S=6,p=p-6||(P=S%E,W)`,E=49) onclick=M=9><canvas id=c>

## archlogo.txt
\033[38;2;23;147;209m                   ▄
                  ▟█▙
                 ▟███▙
                ▟█████▙
               ▟███████▙
              ▂▔▀▜██████▙
             ▟██▅▂▝▜█████▙
            ▟█████████████▙
           ▟███████████████▙
          ▟█████████████████▙

## mypy_json.pyi
# modified from Original source: https://github.com/python/mypy/issues/731#issuecomment-539905783
from typing import Union, Dict, List

JSONPrimitive = Union[str, int, bool, None]
JSONType = Union[JSONPrimitive, 'JSONList', 'JSONDict']

# work around mypy#731: no recursive structural types yet
class JSONList(List[JSONType]):
    pass

## Quirks of C.md

      
              1 file
            
          
              33 forks
            
          
              14 comments
            
          
              446 stars
            
          
                fay59
                / Quirks of C.md
            
            
              Last active
              January 23, 2024 04:24
            
              
                Quirks of C
              
          
    Here's a list of mildly interesting things about the C language that I learned mostly by consuming Clang's ASTs. Although surprises are getting sparser, I might continue to update this document over time.
There are many more mildly interesting features of C++, but the language is literally known for being weird, whereas C is usually considered smaller and simpler, so this is (almost) only about C.
1. Combined type and variable/field declaration, inside a struct scope [https://godbolt.org/g/Rh94Go]

struct foo {
   struct bar {
 int x;

  
## higher_kinded_types_in_rust_and_haskell.md

      
              1 file
            
          
              13 forks
            
          
              0 comments
            
          
              108 stars
            
          
                CMCDragonkai
                / higher_kinded_types_in_rust_and_haskell.md
            
            
              Last active
              June 26, 2024 23:03
            
              
                Rust/Haskell: Higher-Kinded Types (HKT)
              
          
    Rust/Haskell: Higher-Kinded Types (HKT)

A higher kinded type is a concept that reifies a type constructor as an
actual type.
A type constructor can be thought of in these analogies:

like a function in the type universe
as a type with a "hole" in it


## hkt.rs
use std::rc::Rc;

trait HKT<U> {
    type C; // Current type
    type T; // Type with C swapped with U
}

macro_rules! derive_hkt {
    ($t:ident) => {
        impl<T, U> HKT<U> for $t<T> {
	call plug#begin()
	Plug 'drewtempelmeyer/palenight.vim'
	Plug 'vim-airline/vim-airline'
	Plug 'wlangstroth/vim-racket'
	Plug 'sheerun/vim-polyglot'
	Plug 'rust-lang/rust.vim'
	Plug 'preservim/tagbar'
	Plug 'universal-ctags/ctags'
	Plug 'luochen1990/rainbow'
	Plug 'vim-syntastic/syntastic'
	from typing import Generic, Optional, TypeVar
	from abc import ABC, abstractmethod
	from dataclasses import dataclass

	T = TypeVar('T')
	E = TypeVar('E')


	class Result(Generic[T, E], ABC):
	@abstractmethod
	\033[38;2;23;147;209m ▄
	▟█▙
	▟███▙
	▟█████▙
	▟███████▙
	▂▔▀▜██████▙
	▟██▅▂▝▜█████▙
	▟█████████████▙
	▟███████████████▙
	▟█████████████████▙
	# modified from Original source: https://github.com/python/mypy/issues/731#issuecomment-539905783
	from typing import Union, Dict, List

	JSONPrimitive = Union[str, int, bool, None]
	JSONType = Union[JSONPrimitive, 'JSONList', 'JSONDict']

	# work around mypy#731: no recursive structural types yet
	class JSONList(List[JSONType]):
	pass
	use std::rc::Rc;

	trait HKT<U> {
	type C; // Current type
	type T; // Type with C swapped with U
	}

	macro_rules! derive_hkt {
	($t:ident) => {
	impl<T, U> HKT<U> for $t<T> {