| import Network.HTTP.Conduit | |
| import qualified Data.ByteString.Lazy as L | |
| main = simpleHttp "http://www.haskell.org/haskellwiki/Haskell" >>= L.putStr |
| Welcome to Scala version 2.10.0 (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_37). | |
| Type in expressions to have them evaluated. | |
| Type :help for more information. | |
| scala> val x: Option[Nothing] = None | |
| x: Option[Nothing] = None | |
| scala> x match { | |
| | case Some(a) => a | |
| | case None => None |
| case class X[A](ok: Boolean, value: A) { | |
| def map[B](f: A => B): X[B] = | |
| X(ok, f(a)) | |
| def flatMap[B](f: A => X[B]) X[B] = | |
| f(value) | |
| def thenOr[B](f: A => X[B], otherwise: A => B) = | |
| if (ok) then flatMap(f) else map(otherwise) | |
| } |
| scala> ("asd" := 1) | |
| res10: (String, argonaut.Json) = (asd,"1") | |
| scala> ("qwe" :=? Some(1)) | |
| res11: Option[(String, argonaut.Json)] = Some((qwe,"1")) | |
| scala> res10 ->: res11 ->?: jEmptyObject | |
| res12: argonaut.Json = {"asd":"1","qwe":"1"} | |
| scala> ("zxc" := "value") ->: ("nothing" :=? none[String]) ->?: jEmptyObject |
| import scala.concurrent.{Future, ExecutionContext} | |
| import scalaz._, Scalaz._ | |
| object Chunk { | |
| type Chunk[A] = A \/ StreamT[Future, A] | |
| implicit def ApplicativeChunk: Applicative[Chunk] = new Applicative[Chunk] { | |
| def point[A](a: => A) = a.left | |
| override def map[A, B](fa: Chunk[A])(f: A => B): Chunk[B] = |
| java.lang.StackOverflowError | |
| at scala.tools.nsc.symtab.Types$SimpleTypeProxy$class.boundSyms(Types.scala:189) | |
| at scala.tools.nsc.symtab.Types$SingletonType.boundSyms(Types.scala:1040) | |
| at scala.tools.nsc.symtab.Types$SubstMap.apply(Types.scala:3565) | |
| at scala.tools.nsc.symtab.Types$SubstMap.apply(Types.scala:3532) | |
| at scala.tools.nsc.symtab.Types$TypeMap.mapOver(Types.scala:3113) | |
| at scala.tools.nsc.symtab.Types$SubstMap.apply(Types.scala:3567) | |
| at scala.tools.nsc.symtab.Types$SubstMap.apply(Types.scala:3532) | |
| at scala.tools.nsc.symtab.Types$TypeMap.mapOver(Types.scala:3158) | |
| at scala.tools.nsc.symtab.Types$SubstMap.apply(Types.scala:3567) |
Developers are often very good at spotting repetition in their programs at the value level, but for some reason struggle, or are reluctant to, apply that same careful analysis at the type level.
This talk aims to build up an intuition for spotting when you can factor your types, examining what this gains you, and looking at the practicalities for doing so in scala. We will use an example of
| Why do I believe this distinction is important? | |
| Versions are virtual, the express intent not reality. Artifacts are real. How | |
| they are idenitified is up for debate but I am of the belief it is not and | |
| never can be versions. | |
| As a concrete example, if I am using cabal and make the statement that I depend on | |
| version 1.7.* of library barney, I am not stating that I think I work with all | |
| versions of barney that start with 1.7, I am merely stating that my expectations | |
| are that I am compatible with version 1.7 of barney and *believe* that barney intends |
| def makeAp(s : String) : ValidationNEL[Error, Uppercase] = | |
| (notNull(s).toValidationNEL |@| | |
| longerThan8(s).toValidationNEL |@| | |
| uppercase(s).toValidationNEL).apply((_, _, _) => Uppercase(s)) |
| // Don't try this at home | |
| object BrokenLaws { | |
| trait Monoid[F] { | |
| def zero: F | |
| def append(a: F, b: F): F | |
| } | |
| implicit def DoubleMonoid: Monoid[Double] = new Monoid[Double] { | |
| def zero = 0.0 | |
| def append(a: Double, b: Double) = a + b |