vpatryshev

case class Ch(c: Char) { def ~=(x: Char) = c == '.' || c == x }

class RE(val regexp: String) {
  def skip(n: Int) = RE(regexp.substring(n))

  implicit def token(c: Char) = Ch(c)
  def c0 = Ch(regexp(0))
  def c1 = regexp(1)

  def ~=(text: String): Boolean = {

vpatryshev

  /**
   * This trait (typeclass) defines one operation for a parametrized type F
   * the operation is known as fmap in Haskell, f1 in internal categories.
   *
   * For each pair of arbitrary types X, Y and an arbitrary function:X=>Y,
   * it should provide a function F[X]=>F[Y].
   * Providing means that the implementation depends on a specific type F
   * E.g. given F = List, and a function f(n: Int): String = "{{" + n + "}}",
   * we should have a function List[Int]=>List[String] that wraps elements in double braces.
   *

vpatryshev

// we already have a bunch of patient properties on one tab (in props1); now get another bunch from another tab
// we click it and wait for the element to show up; then:
  val props2 = extractProperties("div#ctl00_ContentPlaceHolder1_Details_Container2") map (_.trimPrefixes)
// trimming prefixes means we do not care about all the additional keys, but just a variety of values

// now let's blend the two sets together; <*> will produce either Good((p1,p2)) or Bad(errors1 ++ errors2)
  val propsOpt: Result[(Props, Props)] = props1 <*> props2
// then we want to merge together two sets of patient properties; that's what we do in map
  val patientData = propsOpt map ((xy:(Props, Props)) => (xy._1 ++ xy._2))
  debug(s"Got patient data\n $patientData")

vpatryshev

  def spendNotMoreThan[T](time: Duration) = new {
    def on(op: => Result[T]): Result[T] = {
      var res:Result[T] = Empty
      var done = new AtomicBoolean(false)
      val nanos = time.toNanos
      val upto = System.nanoTime + nanos
      val worker = new Thread {
        override def run {
          res = op
          done.set(true)

vpatryshev

  def downloadPDF(url: String): Result[(File, String)] = {
    loadPage(url) andThen
    waitForSelector("div.textLayer") andThen 
    runJS("return extractPdfContent()") andThen {
      Thread.sleep(2000) // give browser a chance
      val extracted = runJS("return intBuf2hex(extractedPdf)") map (_.toString)
      val pdf = extracted flatMap 
        (_.decodeHex #> File.createTempFile("download", ".pdf"))
      
      val html = runJS("return _$('div.textLayer').innerHTML") map (_.toString)

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;

vpatryshev

### Keybase proof

I hereby claim:

  * I am vpatryshev on github.
  * I am vpatryshev (https://keybase.io/vpatryshev) on keybase.
  * I have a public key whose fingerprint is F7CC C6E9 59DF 55AF 2BE7  676B 31F4 2673 9622 4C88

To claim this, I am signing this object:

vpatryshev

package object types {

  import scala.language.reflectiveCalls
  import scala.language.higherKinds

  // quantifiers aka (co)ends
  type Forall[+F[_]] = { def apply[X]: F[X] }
  type Exists[+F[_]] = F[_]

  // basic categorical notions

vpatryshev

case class BT[T](left: Option[BT[T]], value: T, right: Option[BT[T]]);

def inorder[T](t:BT[T], out: T=>Unit): Unit = {
  val stack: mutable.Stack[(Boolean, BT[T])] = new mutable.Stack[(Boolean, BT[T])]()
  def p(n: BT[T]) = stack.push((false, n))
  p(t)
  while (!stack.isEmpty) {
    (stack.pop() match {
      case (true, top) =>
        out(top.value)

vpatryshev

import java.util.{Collections, Map => JavaMap}
import scala.collection.JavaConverters._

trait EnvHacker {
    /**
     * Portable method for setting env vars on both *nix and Windows.
     * @see http://stackoverflow.com/a/7201825/293064
     */
    def setEnv(newEnv: Map[String, String]): Unit = {
        try {