etorreborre

package org.scalabound.scatdd.specs2

import org.scalabound.scatdd.FizzBuzz
import org.junit.runner.RunWith
import org.specs2.runner.JUnitRunner

// package unitTest { |> Scala IDE will not pick the class up as runnable if I sub-package it like this :-(
@RunWith(classOf[JUnitRunner])
class FizzBuzzJUnitSpec extends org.specs2.mutable.Specification {
    

etorreborre

case class T() // your data type that you want to "implicitly" thread through

case class TReader[+A](run: T => A) {
  def map[B](f: A => B): TReader[B] =
    sys.error("VFJlYWRlcihmIGNvbXBvc2UgcnVuKQ==")

  def flatMap[B](f: A => TReader[B]): TReader[B] =
    sys.error("VFJlYWRlcih0ID0+IGYocnVuKHQpKSBydW4gdCk=")

  def &&&[B](x: TReader[B]): TReader[(A, B)] =

etorreborre

The z in scalaz means this: it was early 2008 and I was working for a Java consultancy and so of course, I used the most appropriate tool for the job: scala. But it had *terrible* libraries, so I offered to fix those while also meeting my other objectives. Turns out that the Scala guys were extremely hostile to even half-decent libraries (and still are to this day). I still struggle to wrap my head around this sometimes.

Anyway, so I thought, well fuck it, I will just keep them to myself for now. My (awesome) employer had already agreed that we'd probably open-source such a thing, but I was concerned most about my primary goal. So then it came time to "name" this library. I had named it "scalax" simply so that I did not have the inclination to think of a proper name. Then I found out that such a library was being developed and with my internal name! Whatever, I thought.

So I looked at this scalax library, hoping that I could just abandon my efforts and jump on board with everyone else -- they too had figure

etorreborre

//
// Copyright 2013 Paytronix Systems, Inc.
//
// 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
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software

etorreborre

# Get yourself sbt-extras
# Or: brew install sbt
alias scalaz="sbt -sbt-create 'set libraryDependencies += \"org.scalaz\" %% \"scalaz-core\" % \"7.1.0-M4\"' 'set initialCommands := \"import scalaz._; import Scalaz._\"' 'console'"

etorreborre

package com.ambiata.ivory.scoobi

import org.specs2._
import com.nicta.scoobi.Scoobi._
import com.nicta.scoobi.testing.mutable._
import com.nicta.scoobi.testing.SimpleJobs
import com.nicta.scoobi.testing.TestFiles._
import com.nicta.scoobi.testing.TempFiles
import scalaz.{DList => _, _}, Scalaz._

etorreborre

So what I understand to be your questions:

1. What is a coherency problem?
2. What does over constained code look like / cause?
3. How do you lose your "desired" instance?

A way to step through understanding this problem:

• Oh shit, If I have local type classes, I have to handle crazy wacky cases in my implementation, this will likely have performance and correctness implications (see Coherency.scala)
• What happens if I close over constraint on construction? Oops if I close over it, I end up with OverConstrained code (see OverConstrainedCode.scala) and worse I still have coherency issues, and the ability to lose my intended behavious (LosingAnInstance.scala)
• Oh wow, if I just don't do local type classes, by never define conflicting implicits, and ascribe a single type to each behaviour, everything is simple and just works.

etorreborre

class ext extends StaticAnnotation {
  def macroTransform(annottees: Any*) = macro extension.impl
}

object extension {
  def impl(c: Context)(annottees: c.Expr[Any]*): c.Expr[Any] = {
    import c.universe._
    annottees.map{ _.tree }.head match {
      case q"def $name[..$tp](...$params): $ret = $b" =>
        val Seq(Seq(thiz, rest @ _*), rest2 @ _*) = params

etorreborre

import scodec.codecs
import scodec.bits.{BitVector,ByteVector}
import scalaz.stream.{Process1,Process}

object Unframing {
  
  /** 
   * Break an input bytestream along frame boundaries. Input consists of a stream of frames, 
   * where each frame is just a number of bytes, encoded as an int32, followed by a packet of 
   * that many bytes. End of stream is indicated with a frame of size <= 0. Output stream is

etorreborre

object IO2a {

  /*
  The previous IO representation overflows the stack for some programs.
  The problem is that `run`
  */

  sealed trait IO[A] {
    def flatMap[B](f: A => IO[B]): IO[B] =
      FlatMap(this, (a: A) => Suspend { () => f(a) }) // note this returns immediately