bvenners

One way Scalaz's === operator differs from ScalaUtils is that Scalaz does not define default
Equal instances whereas ScalaUtils does provide default Equality and Equivalence instances.
Scalaz provides Equal instances for Int and List[Int], for example, but it doesn't do so for
mutable objects. Thus by default you can compare Ints and List[Int]s with === in Scalaz, but
not arrays:

scala> import scalaz._
import scalaz._

scala> import Scalaz._

bvenners

// If you paste this code into the Scala interpretter with ScalaUtils on the path:

List(1) contains 1
List(1) contains "1"

import scala.collection.GenSeq
implicit class Containz[A](xs: GenSeq[A]) {
  def containz[B <: A](ele: B): Boolean = xs.exists(_ == ele)
}

bvenners

scala> List(1, 2, 3) contains 1
res5: Boolean = true

scala> List(1, 2, 3) contains "1"
res6: Boolean = false

scala> import scala.collection.GenSeq
import scala.collection.GenSeq

scala> implicit class Containz[A](xs: GenSeq[A]) {

bvenners

// TEST 1 - FAIL
package foo

import org.scalautils._
import org.scalatest._
import Matchers._
import TypeCheckedTripleEquals._

class Work {
  1 should === ("aoeu")

bvenners

// Questions about \/ and Validation
object scalaz {

/*
Thanks for the great explanation, Tony. This explanation as well as the answers
that came back from Runar and Mark nudged my thinking in a different direction.
The feeling I get is that there's a monad inside of Validation trying to get out.
It looks like Validation would be monadic just from its shape, and users seem to
want to use them in for expressions. I now see that a Validation monad would need

bvenners

// Here is code that can be pasted into the REPL

import scalaz._
import Scalaz._
import org.scalautils._
def all[F[_]: Applicative, A](s: String, parsers: List[String => F[A]]): F[List[A]] = parsers.traverse(p => p(s))
implicit class BadDog[G, B](or: Or[G, B]) {
  def badMap[C](bToC: B => C): G Or C = or.swap.map(bToC).swap
}
trait LowPriorityImplicit {

bvenners

// Here's code that can be pasted into an interpreter sesssion:
import scalaz._
import Scalaz._
import org.scalautils._
def all[F[_]: Applicative, A](s: String, parsers: List[String => F[A]]): F[List[A]] = parsers.traverse(p => p(s))
implicit class BadDog[G, B](or: Or[G, B]) {
  def badMap[C](bToC: B => C): G Or C = or.swap.map(bToC).swap
}
def toIntE(s: String): Int Or ErrorMessage = attempt(s.toInt).badMap(_.getMessage)
def one: String => (Int Or List[ErrorMessage]) = s => toIntE(s).badMap(List(_))

bvenners

/**
 *  Copyright (C) 2009-2013 Typesafe Inc. <http://www.typesafe.com>
 */
package akka.cluster

import scala.collection.immutable.SortedSet
import com.typesafe.config.ConfigFactory
import akka.remote.testkit.MultiNodeConfig
import akka.remote.testkit.MultiNodeSpec
import akka.testkit._

bvenners

{ 
  // do first step
  // pure assert first side effect
} && {
  // do second step
  // pure assert second side effect
} && {
  // do third step
  // pure assert third side effect
}

bvenners

import org.scalatest._
import Matchers._
import tagobjects._

class ExampleSpec extends FreeSpec {

    override lazy val tags: Map[String, Set[String]] =
      super.tags.transform {
        case (testName, tagsSet) if testName startsWith "scope1" => tagsSet + "Scope1"
        case (testName, tagsSet) if testName startsWith "scope2" => tagsSet + "Scope2"