[info] FormattersSpec
[info]   Formatters are invertible for:
[info]     + Mapping
[info]     + Identifier
[info]
[error]     x Metadata
[error]  Gave up after only 39 passed tests. 197 tests were discarded. (FormattersSpec.scala:11)

This test generates random Metadata values and makes sure that they can be serialised and deserialised correctly (i.e. values can be round-tripped). The property being test here is identical, only the Arbitrary, Serialise, and Deserialise instances vary in each case. The truly odd thing is that the pertinent code looks like this:

case class Identifier(name: String)
case class Metadata (id: Identifier, maps: Set[Identifier])

implicit val ArbIdentifier = Arbitrary(
  for {
    name  <- arbitrary[String]
  } yield Identifier(name)
)

implicit val ArbMetadata = Arbitrary(
  for {
    identifier <- arbitrary[Identifier]
    mappings   <- arbitrary[Set[Identifier]]
  } yield Metadata(identifier, mappings)
)

My first step was redefining a few related Arbitrary instances to avoid using suchThat (which discards invalid values) but this didn’t fix the problem. Eventually I tried redefining ArbMetadata like this:

implicit val ArbMetadata = Arbitrary(
  for {
    identifier <- arbitrary[Identifier]
    mappings   <- Gen.const(Set.empty[Set[Identifier]])
  } yield Metadata(identifier, mappings)
)

and the problem went away. Trying to use arbitrary[Set[Identifier]] in various ways in the Scala REPL confirmed that it is the problem; we can easily generate as large a List[Identifier] as we like, but a Set[Identifier] fails fairly frequently:

// This always generates a Some[List[Identifier]] value.
Gen.listOfN(100, arbitrary[Identifier]).map(_.length).sample
// Sometimes we get a Some[List[Set[Identifier]]] and others None.
Gen.listOfN(100, arbitrary[Set[Identifier]]).map(_.length).sample

It appears as though whatever mechanism is used by arbitrary[Set[_]] to construct the sets, it doesn’t fails when the generator for the value type returns duplicate elements. You can confirm this easily by trying arbitrary[Set[Unit]]; any Gen[Unit] has no choice but to return a the single value of type Unit (or to fail) and, as expected, this almost never succeeds. Replacing the problematic arbitrary[Set[Identifier]] in the original code with arbitrary[Seq[Identifier]].map(_.toSet) resolves the issue: constructing a set from a list of possibly duplicate Identifiers always works.

After a bit of reading in the ScalaCheck source code it seems as though the root cause of this problem is some instance of CanBuildFrom[Set[_], A, Set[A]] but I’ve no idea how to go about figure out which one or why it’s broken. In any case, I now know a bit more about working with Scala.

For more information, see the ScalaCheck issue #89.

Jed on variance (in Scala)

Variance is essentially about substitution or sub-typing. A thing that produces a Super may be replaced with a thing that takes Sub. A think that that takes Sub may be replaces by a thing that takes `Super.

Rat -> Real <: Int -> Complex

Reference to

Be liberal in what you accept and conservative in what you produce.

Use site variance in Java

final function Option<a>

In Scala:

List[+A]

Function[-T1, +R]

Kleisli[M[+_], -A, +B]

Eg:

class GPar
class Par extends GPar
class Child extends Par

class Box[+A]

def foo(x:Bor[Par]): 

foo(Box[Child])
foo(Box[GPar]) // error

f

trait Box[+A] {
	def get: A
	def take(a: A) // Error
}

trait Box[-A] {
	def get: A
	def take(a: A)
}

Functor

trait Functor[F[_]] {
	def map[A,B](a: F[A])(f: A => B): F[B]
}

This is actually a contra-variant functor.

trait Contravariant[F[_]] {
	def contramap[A,B](r: R[A])(f: B=>A): F[B]
}

Variance in mutable values:

Two type variables. One goes up (things coming out?), one goes down (things going in?).

http://biosimilarity.blogspot.com.au/2011/05/of-monads-and-games.html

Tim on monoid

class Monoid a where
    mempty :: a
    mappend :: a -> a -> a

Obeys laws

mappend a mempty == a
mappend mempty a == a
mappend a (mappend b c) == mappend (mappend a b) c

Given types may have multiple monoids: numbers have (+, 0) and (*, 1).

Define monoids to do min, max, count on the pattern of Sum and Product. Have a smart constructor for each

The foldable type-class makes fold polymorphic.

class Foldable t where
    foldMap :: Monoid m => (a -> m) -> t a -> m

Use the monoids we defined earlier:

foldMap sum as
foldMap count as
foldMap max as

The mappend operation distributes through structures like tuple types too. This lets apply multiple monoids with one traversal.

a2 :: Applicative a => a b -> a c -> a (b, c)
a2 b c = (,) <$> b <*> c

> foldMap (a2 min max) as
(Min 1, Max 456)

This doesn’t let us do Mean very nicely. We need to unpack the pair at the end and calculate the actual

Have an additional Aggregation class (superclass of Monoid) which has an associated type for the result which is extracted from the aggregation.

So we can make a version of foldMap which can finish and unwrap the aggregation:

afoldMap :: (Foldable t, Aggregation a) => (v -> a) -> t v -> AggResult a
afoldMap f vs = AggResult (foldMap f vs)

Combine the aggregation and monoid to apply a filter during the single traversal.

Two monoids for maps:

1. Replace the values

2. Insist the values are monoids too and append them.

Compose accessors with the “smart” constructors and apply them to calculate statistics over a stream of records.

Amos Robinson on optimising purely functional loops

Live at UNSW and looking at some optimisation problems. SpecConstr (constructor specialisation) is part of GHC (phase? optimisation?); has some problems, particularly with stream fusion, DPH, etc.

Dot product (pairwise multiple two vectors and sum the results) is a motivating example. We want to write that as:

dotp as bs = fold (+) 0 $ zipWith (*) as bs

But we want to actually execute:

dotp as bs = go 0 0
  where
    go i acc
    | i > V.length as
    = acc
    | otherwise
    = go (i+1) (acc + (as!i * bs!i))

(Assuming that the Ints aren’t boxed, etc.)