Just run this from your Mac terminal and it'll drop you in a container with full permissions on the Docker VM. This also works for Docker for Windows for getting in Moby Linux VM (doesn't work for Windows Containers).
docker run -it --rm --privileged --pid=host justincormack/nsenter1
more info: https://github.com/justincormack/nsenter1
When defining complex functions in pointfree style, I often find myself switching to pointful style. Sometimes, I even convert to ANF and annotate the types to understand the steps.
After completing the function definition, I often convert back to pointfree style for conciseness. End of the story: To understand it again a couple of weeks later, I start expanding to annotated pointful again.
The small 10-lines library at the end of this post allows to define pointfree functions with intermediate type annotations.
Credits: Agda and EqReasoning for syntactical inspiration.
| {-# OPTIONS --copatterns #-} | |
| module Main where | |
| -- A simple cat program which echoes stdin back to stdout, but implemented using copatterns | |
| -- instead of musical notation, as requested by Miëtek Bak (https://twitter.com/mietek/status/806314271747481600). | |
| open import Data.Nat | |
| open import Data.Unit | |
| open import Data.Bool | |
| open import Data.Char |
Copyright © 2016-2018 Fantasyland Institute of Learning. All rights reserved.
A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.
val square : Int => Int = x => x * x
In abstract, the job of ghc --make is very simple: compute
a dependency graph between modules, and rebuild the ones that
have changed. Unfortunately, the code in GhcMake is quite
a bit more complicated than that, and some of this complexity
is essential to the design of GHC:
| // Initial idea courtesy of @dwijnand | |
| // Improved by @fthomas | |
| sealed trait List[+T] { | |
| def head: Option[T] | |
| } | |
| final case class Cons[T](h: T, t: List[T]) extends List[T] { | |
| val head: Some[T] = Some(h) | |
| } |
No need for homebrew or anything like that. Works with https://www.git-tower.com and the command line.
gpg --list-secret-keys and look for sec, use the key ID for the next stepgit to use GPG -- replace the key with the one from gpg --list-secret-keys
| module IrrelevanceExample where | |
| open import Data.Nat | |
| open import Relation.Binary.PropositionalEquality | |
| postulate | |
| p₁ : 0 ≤ 1 | |
| p₂ : 0 ≤ 1 |
In response to a request on Reddit, I'm writing up my thoughts on PVP upper bounds. I'm putting this in a Gist since I don't want to start yet another debate on the matter, just provide some information to someone who asked for it. Please don't turn this into a flame war :)
For those unaware: the Package Versioning Policy is a set of recommendations covering how to give version numbers to your packages, and how to set upper and lower bounds on your dependencies.
I'll start by saying: I support completely with the PVP's recommendations on how to assign version numbers. While there are plenty of points in this design space, the PVP is an unobjectionable one, and consistency in the community is good. On multiple occasions, I have reached out to package authors to encourage compliance with this. (However, I've always done so privately, as opposed to a statement on Reddit, as I believe that to be a more likely route to successful convincing.)
The issue aro