bitemyapp

The Learning Haskell guide has been moved to a git repo to enable outside contribution

Find it here: https://github.com/bitemyapp/learnhaskell

shajra

import concurrent.{ExecutionContext, Future => SFuture, Promise}                 
import util.Try                                                                                                 
                                                                                                                
import _root_.scalaz.\/                                                                                         
import _root_.scalaz.concurrent.{Task => ZTask}                                                                 
                                                                                                                
                                                                                                                
object Task {                                                                                                   
                                                                                                                
  def fromScala[A]                    

vmarquez

    //Reader Monad and its extension class to give it SelectMany(bind/flatMap) capabilities for use in LINQ queries
    public static class ReaderMonadExt
    {
        public static ReaderMonad<T, C> SelectMany<T, A, B, C>(this ReaderMonad<T, A> rm, Func<A, ReaderMonad<T, B>> bindf, Func<A, B, C> select)
        {
            return new ReaderMonad<T, C>(t =>
            {
                var a = rm.Run(t);
                return select(a, bindf(a).Run(t));
            });

vpatryshev

import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Arrays;
import java.util.Map;
import java.util.IdentityHashMap;
import java.util.LinkedList;
import java.util.SortedSet;
import java.util.TreeSet;

runarorama

import scalaz._, Scalaz._

// Adjunction between `F` and `G` means there is an
// isomorphism between `A => G[B]` and `F[A] => B`.
trait Adjunction[F[_],G[_]] {
  def leftAdjunct[A, B](a: A)(f: F[A] => B): G[B]
  def rightAdjunct[A, B](a: F[A])(f: A => G[B]): B
}

// Adjunction between free and forgetful functor.

aloiscochard

#!/usr/bin/env bash

############
# QuickSBT #
############

# Launch SBT with support for generating /tmp/sbt.quickfix file for Vim
# http://github.com/aloiscochard / https://gist.github.com/4698501

# Error format for SBT, and shortcut to open SBT quickfix file :

shajra

When scala.util.Try first came out, there was a lot of discussions about the validity of it's implementation. Some discussions got distracted with issues beyond the facts. Ultimately, the issue came down to the following:

1. Is Try a monad?

2. Does referential transparency (RT) apply in the presence of possible non-terminating or errant functions -- those returning ⊥?

Not requiring Try to be a monad is an easy solution to the whole problem. If

dscleaver

import scalaz._
import Scalaz._

object monads {

  def fix[A](f: (=> A) => A): A = f(fix(f))       //> fix: [A](f: => A => A)A
  
  type Gen[A] = (=> A) => A
  
  def gFib: Gen[Int => Int] = (self) => n =>

paulp

// [info] Running p.Run
// List(Fish(Bob, Esq.,12), Kitty(Thor, Esq.,java.awt.Color[r=255,g=200,b=0]))

import java.awt.Color

package p {
  trait Pet[A] {
    def name(a: A): String
    def renamed(a: A, newName: String): A
  }

japgolly

import scalaz.{LensFamily, Lens}
import Lens.{lensg, lensFamilyg}

object LensFns {

  /**
   * A lens that requires a key be provided to extract B from A.
   *
   * @tparam A The record type.
   * @tparam K The field key type.