Skip to content

Instantly share code, notes, and snippets.

Miles Sabin milessabin

Block or report user

Report or block milessabin

Hide content and notifications from this user.

Learn more about blocking users

Contact Support about this user’s behavior.

Learn more about reporting abuse

Report abuse
View GitHub Profile
milessabin / tuplegeneric.scala
Last active Sep 27, 2019
Convert (small enough) case classes to and from tuples using shapeless ...
View tuplegeneric.scala
import shapeless._
import ops.hlist.Tupler
trait TupleGeneric[C <: Product] extends Serializable {
type Repr <: Product
def to(t : C) : Repr
def from(r : Repr) : C
milessabin / gist:1705644
Created Jan 30, 2012
Access to companion object of Foo via implicit resolution
View gist:1705644
trait Companion[T] {
type C
def apply() : C
object Companion {
implicit def companion[T](implicit comp : Companion[T]) = comp()
object TestCompanion {
milessabin / gist:cadd73b7756fe4097ca0
Last active Sep 16, 2019
A new approach to encoding dependently-typed chained implicits, using singleton types ...
View gist:cadd73b7756fe4097ca0
object Demo {
// A couple of type classes with type members ...
trait Foo[T] {
type A
object Foo {
implicit val fooIS = new Foo[Int] { type A = String }
View match-types.scala
* Copyright (c) 2019 Miles Sabin
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* Unless required by applicable law or agreed to in writing, software
View tupletype.scala
def tupleType(tpes: List[Type]): Type = {
val PairType = typeOf[_ *: _] match {
case Type.IsAppliedType(tp) => tp.tycon
def nestedPairs(tpes: List[Type], acc: Type): Type = tpes match {
case Nil => acc
case hd :: tail => nestedPairs(tail, Type.AppliedType(PairType, List(hd, acc)))
View ambiguous.scala
object Utils {
type Id[t] = t
type Const[c] = [t] => c
import Utils._
class Instances[F[_[_]], T[_]]
trait Functor[F[_]]
milessabin / gist:2659013
Created May 11, 2012
Proving equality of type constructors in Scala via an "arbitrary object" encoding of universal quantification.
View gist:2659013
// Universal quantification is encoded in terms of quantifier-free
// assertions about an "abitrary" type (cp. "all swans are white" vs.
// "the arbitrary swan is white". Inspired by Kit Fine's 1985 "Reasoning
// with Arbitrary Objects",
// Possibly also related to Oleg Kiselyov's "Interpreting types as
// abstract values",
// What I wouldn't give for kind-polymorphism here ...
View gist:de58f3ba7024d51dcc1a
def unexpected : Nothing = sys.error("Unexpected invocation")
// Encoding for "A is not a subtype of B"
trait <:!<[A, B]
// Uses ambiguity to rule out the cases we're trying to exclude
implicit def nsub[A, B] : A <:!< B = null
implicit def nsubAmbig1[A, B >: A] : A <:!< B = unexpected
implicit def nsubAmbig2[A, B >: A] : A <:!< B = unexpected
milessabin / gist:9042788
Created Feb 17, 2014
Boilerplate free conversion from case classes to shapeless records via LabelledGeneric ... coming soon to shapeless 2.0.0.
View gist:9042788
scala> import shapeless._, record._
import shapeless._
import record._
scala> case class Person(name: String, address: String, age: Int)
defined class Person
scala> val joe = Person("Joe", "Brighton", 33)
joe: Person = Person(Joe,Brighton,33)
You can’t perform that action at this time.