danstn

-- | simple/basic Scala -> Haskell translation of Runar's presentation
-- | (https://dl.dropboxusercontent.com/u/4588997/ReasonablyPriced.pdf)
-- | trying to use minimal extensions and magic. 
-- | (earlier I had a version using MultiParamTypeClasses for Runar's
-- | Inject class, but scraped it opting for simplicity)
-- | my question: what do we lose by moving towards simplicity?
-- | Future work: use DataKinds, TypeOperators, and potentially TypeFamilies
-- | to maintain and automate the folding of types in Coproduct.

{-# LANGUAGE Rank2Types, DeriveFunctor #-}

danstn

sealed trait Interact[A]

case class Ask(prompt: String)
  extends Interact[String]

case class Tell(msg: String)
  extends Interact[Unit]

trait Monad[M[_]] {
  def pure[A](a: A): M[A]

danstn

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveFunctor #-}

import           Prelude
import           Data.String
import           Control.Monad.Free

type Program a r = Free (AST a) r

data AST a next =

danstn

#!/usr/bin/env runhaskell

{-# LANGUAGE OverloadedStrings #-}

import Turtle

main :: IO ()
main = do
  stdout (runWatch $ findSrc)

danstn

function chjava() {
  if [ $# -ne 0 ]; then
    removeFromPath '/System/Library/Frameworks/JavaVM.framework/Home/bin'
    if [ -n "${JAVA_HOME+x}" ]; then
      removeFromPath $JAVA_HOME
    fi
    export JAVA_HOME=`/usr/libexec/java_home -v $@`
    export PATH=$JAVA_HOME/bin:$PATH
  fi
}

danstn

sealed trait Opt[+A] {
  def flatMap[T](f: A => Opt[T]): Opt[T] = 
    fold[Opt[T]](Nothing)(f)
 
  def map[T](f: A => T): Opt[T] = 
    fold[Opt[T]](Nothing)(a => Something(f(a)))
 
  def fold[B](g: => B)(f: A => B): B =
    this match {
      case Something(a) => f(a)

danstn

# An equilibrium index of a sequence is an index into the sequence 
# such that the sum of elements at lower indices is equal to the 
# sum of elements at higher indices.

def eq_indices(arr)
  left, right = 0, arr.inject(0, :+)
  result = []
  arr.each_with_index do |el, i|
    right -= el
    result << i if right == left