| class RichOrdering[A](oa: Ordering[A]) { | |
| def thenBy[B: Ordering](f: A => B): Ordering[A] = new Ordering[A] { | |
| def compare(a1: A, a2: A) = oa.compare(a1, a2) match { | |
| case 0 => Ordering[B].compare(f(a1), f(a2)) | |
| case x => x | |
| } | |
| } | |
| } | |
| implicit def ToRichOrdering[A](oa: Ordering[A]): RichOrdering[A] = new RichOrdering(oa) |
| Hello scala, my old friend | |
| I've come to take you home again | |
| Because a feature slowly creeping | |
| left me plagued with doubts and weeping | |
| and the version that was tagged in the repo | |
| just has to go | |
| it lacks the signs of soundness | |
| On sleepless nights I hacked alone | |
| applying ant and other tools of stone |
| // Just before switching jobs: | |
| // Add one of these. | |
| // Preferably into the same commit where you do a large merge. | |
| // | |
| // This started as a tweet with a joke of "C++ pro-tip: #define private public", | |
| // and then it quickly escalated into more and more evil suggestions. | |
| // I've tried to capture interesting suggestions here. | |
| // | |
| // Contributors: @r2d2rigo, @joeldevahl, @msinilo, @_Humus_, | |
| // @YuriyODonnell, @rygorous, @cmuratori, @mike_acton, @grumpygiant, |
| yonedaLemma = Iso (flip fmap) ($ id) |
| module Primes where | |
| open import Level using (_⊔_) | |
| open import Coinduction | |
| open import Function | |
| open import Data.Empty | |
| open import Data.Unit | |
| open import Data.Nat | |
| open import Data.Nat.Properties | |
| open import Data.Nat.Divisibility |
This is material to go along with a 2014 Boston Haskell talk.
We are going to look at a series of type signatures in Haskell and explore how parametricity (or lack thereof) lets us constrain what a function is allowed to do.
Let's start with a decidedly non-generic function signature. What are the possible implementations of this function which typecheck?
wrangle :: Int -> Int
Simply put, destructuring in Clojure is a way extract values from a datastructure and bind them to symbols, without having to explicitly traverse the datstructure. It allows for elegant and concise Clojure code.
Every application ever written can be viewed as some sort of transformation on data. Data can come from different sources, such as a network or a file or user input or the Large Hadron Collider. It can come from many sources all at once to be merged and aggregated in interesting ways, and it can be produced into many different output sinks, such as a network or files or graphical user interfaces. You might produce your output all at once, as a big data dump at the end of the world (right before your program shuts down), or you might produce it more incrementally. Every application fits into this model.
The scalaz-stream project is an attempt to make it easy to construct, test and scale programs that fit within this model (which is to say, everything). It does this by providing an abstraction around a "stream" of data, which is really just this notion of some number of data being sequentially pulled out of some unspecified data source. On top of this abstraction, sca
A few months ago, Sam Tobin-Hochstadt explained to me how occurrence typing is compositional. While I had taken this for granted previously, comparing occurrence typing to other systems makes it clear that this is an important property to have.
First of all, what is occurrence typing? In dynamically typed programs, there are often type invariants enforced at program branches.
(fn [a :- (U nil String)]
(if a
(count a)A primer/refresher on the category theory concepts that most commonly crop up in conversations about Scala or FP. (Because it's embarassing when I forget this stuff!)
I'll be assuming Scalaz imports in code samples, and some of the code may be pseudo-Scala.
A functor is something that supports map.
