oxbowlakes

//I have a Java interface which looks like this

trait ConsumableResource[A <: AnyRef] extends AutoCloseable {
  /** returns `null` when we are ended */
  def take(): A 
  
}

//I would like to make this viewable as a scala `TraversableOnce` where the resource is automatically closed at the end of the traversal

oxbowlakes

object Lenses {
  /*
   This gist shows that LensP (modification inside a functor) is isomorphic to LensR (getter and setter)
   In particular, it shows that you can derive the signature: S => A from (A => F[A]) => (S => F[S])
   
   This is puzzling at first glance, because it gives rise to the question:
     "if I end up with an F[S], how can I get a A out of it?"
     
  We use the Const type where Const[A, X] = X. Note that Const[_, X] is a functor, but will always return 
  the value X which was originally stored in it!

oxbowlakes

package gsa.domain.scala.dan

import scalaz.Leibniz.===
import scalaz._
import Scalaz._

import gsa.shared.scala._ //gets you Date, Instant types

/**
 * We wish to use a DomainService to get a snapshot of our domain (e.g. Books and SubBusinessUnits).

oxbowlakes

  object ReferenceDirective extends Enumeration {
    val Replace, DoNotReplace = Value

    def replace: Value = Replace
    def doNotReplace: Value = DoNotReplace
  }
  import java.util.concurrent.atomic._
  import scalaz._
  
  /**

oxbowlakes

//requires scala 2.10.x
//requires scalaz-2.10-7.0.x


package fpx

// Furnace types (in reality, these come from a Java API and are real!)

trait FurnaceService {
  def createSession(user: String, password: String): FurnaceSession

oxbowlakes

package fewchaz

import scala.util.{Failure, Success, Try}
import scala.concurrent.{CanAwait, ExecutionContext}
import java.util.concurrent._
import scala.util.control.NonFatal

trait Fewcha[T] extends scala.concurrent.Future[T] {
  def futr: Future[T]
  private[this] final def toTry: Try[T] = try util.Success(futr.get()) catch { case NonFatal(t) => util.Failure(t)}

oxbowlakes

import java.math.BigInteger

/**
 * Clients can use this class instead, which means they only need fill in the 
 * V compute(K) method
 */ 
abstract class ConcCache2<K, V> {
  
  private final ConcCache<K, V> cache = new ConcCache<>();
  

oxbowlakes

///////////////////////////////////////////////////////////////////////
// You are supplied with the following interfaces/implementations
///////////////////////////////////////////////////////////////////////

/** Interface representing the performing of a computation at some specific key */
public interface Computation<K, V> {
  K key();
  V compute();
}

oxbowlakes

<?xml version="1.0" encoding="UTF-8"?>
<scheme name="OxbowSolarizedDark2" version="124" parent_scheme="Default">
  <option name="LINE_SPACING" value="1.2" />
  <option name="EDITOR_FONT_SIZE" value="13" />
  <option name="EDITOR_FONT_NAME" value="Consolas" />
  <colors>
    <option name="ADDED_LINES_COLOR" value="" />
    <option name="ANNOTATIONS_COLOR" value="2b36" />
    <option name="ANNOTATIONS_MERGED_COLOR" value="" />
    <option name="CARET_COLOR" value="dc322f" />

oxbowlakes

import scalaz._;import Scalaz._; import concurrent._

/* Imagine you have some expensive calculations you wish to make: */
trait RawApi {
  def expensiveInt: Int = Int.MaxValue
  def expensiveString: String = "expensive"
}

/* You wish to write a program using this API */
case class Result(i: Int, s: String)