Rahul Goma Phulore missingfaktor

Prereq:

apt-get install zsh
apt-get install git-core

Getting zsh to work in ubuntu is weird, since sh does not understand the source command. So, you do this to install zsh

	/*
	* Copyright (c) 2012 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
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software

	import scalaz.Apply
	import org.scalacheck.Gen
	import org.scalacheck.Arbitrary._

	/**
	* Use this trait to get applicative syntax when building generators. This
	* is especially useful when building generators for case classes.
	*
	*/
	trait Data {

	package scalaz.example


	object Reader extends App {

	/**
	* Manual propagation of the environment (in the example, `contextRoot`.)
	*/
	object Config0 {
	def fragment1(contextRoot: String) = <a href={contextRoot + "/foo"}>foo</a>

	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

	import scalaz._
	import Scalaz._
	import effects._

	object ExperimentingWithIo {

	def main(args: Array[String]): Unit = {

	val i1: IO[Unit] = for {
	_ <- putStrLn("What's your name?")

	package demo

	class Coder(words: List[String]) {

	private val mnemonics = Map(
	'2' -> "ABC", '3' -> "DEF", '4' -> "GHI", '5' -> "JKL",
	'6' -> "MNO", '7' -> "PQRS", '8' -> "TUV", '9' -> "WXYZ")

	/** Invert the mnemonics map to give a map from chars 'A' ... 'Z' to '2' ... '9' */
	private val charCode: Map[Char, Char] =

	import scalaz._
	import Scalaz._

	object MonadTransformerExamples {
	def main(args: Array[String]) = run

	def run {
	// ------------------------------------------------------
	// Combined Option/Option
	// ------------------------------------------------------

	trait MyOption[+A] {
	// single abstract method
	def cata[X](some: A => X, none: => X): X

	import MyOption._

	def map[B](f: A => B): MyOption[B] = cata(f andThen some, none)

	// Also
	// def map[B](f: A => B): MyOption[B] = flatMap(f andThen some)

	trait Enum { //DIY enum type
	import java.util.concurrent.atomic.AtomicReference //Concurrency paranoia

	type EnumVal <: Value //This is a type that needs to be found in the implementing class

	private val _values = new AtomicReference(Vector[EnumVal]()) //Stores our enum values

	//Adds an EnumVal to our storage, uses CCAS to make sure it's thread safe, returns the ordinal
	private final def addEnumVal(newVal: EnumVal): Int = { import _values.{get, compareAndSet => CAS}
	val oldVec = get