Arneball

## Backend.java
package com.example.android2111.app;

import java.util.List;

import retrofit2.Call;
import retrofit2.Retrofit;
import retrofit2.http.GET;
import retrofit2.http.Path;
import retrofit2.converter.gson.GsonConverterFactory

## gist:43c48e2bf2d4f4e88fbc
scala> :paste
// Entering paste mode (ctrl-D to finish)

trait Context

object Helper {
  def stuff(implicit c: Context) = 3
  def stuff_=(i: Int)(implicit c: Context) = ()

  // woot

## gist:c003923f417c74b3329c
class Str(val str: String) extends AnyVal {
  def isEmpty = str == null || str.isEmpty
  def _1 = str.charAt(0)
  def _2 = str.substring(1)
}
object Str {
  def unapply(str: String): Str = new Str(str)
}

object StrTest {

## gist:0e47ce989aa928afe055
object MySorts extends Ordering.ExtraImplicits {

  def mergeSort[T : Ordering](elems: List[T]): List[T] = elems match {
    case Nil | _::Nil => elems
    case that =>
      type L = List[T]
      def merge(l1: L, l2: L, acc: L): L = l1 -> l2 match {
        case (a::as, b::_) if a < b => merge(as, l2, a::acc)
        case (_, b::bs) =>  merge(l1, bs, b::acc)
        case (a::as, _) =>  merge(as, l2, a::acc)

## gist:b9d47b352ca460590023
Compiled from "MyInterface.java"
public interface batik.MyInterface {
 public abstract java.util.List<java.lang.String> strings();

 public int totalLength(); // OBSERVERA DEFAULT METHOD I INTERFACE
   Code:
      0: iconst_0
      1: istore_1
      2: aload_0
      3: invokeinterface #1,  1            // InterfaceMethod strings:()Ljava/util/List;

## gist:276ec14faa79be2d2b49
trait WkRef[+T >: Null <: AnyRef] extends WeakReference[T @uncheckedVariance] {
  def map[U >: Null <: AnyRef](f: T => U): WkRef[U] = if(isDefined) new WeakRef[U](f(get)) else WeakNone
  def flatMap[U >: Null <: AnyRef](f: T => WkRef[U]) = if(isDefined) f(get) else WeakNone
  def isDefined: Boolean
  def foreach[U](f: T => U) = if(isDefined) f(get)
  def filter(f: T => Boolean): WkRef[T] = if(isDefined && f(get)) this else WeakNone
}
object WkRef {
  def apply[T >: Null <: AnyRef](t: T) = t match {
    case null => WeakNone

## gist:5b7e2e90d889ef9d30ed
/**
 * Created by arneball on 2014-06-14.
 */
object ExtractorTest extends App with Integral.ExtraImplicits{
  @extract def longString(str: String) = str.length > 1

  @extract def cool(int: Int) = Option(int).filter{ 2 < _ }.map{ 2 * }

  @extract def evensum[T : Integral](l: List[T]) = {
    l.sum % implicitly[Integral[T]].fromInt(2) == 0

## gist:392ea620693697414b24
/**
 * Created by arneball on 2014-05-31.
 */
object LazyTest extends App {
  val n = new LazyTest
  try {
    println(n.lazyIntInDaHouse)
  } catch { case t: Throwable => }
  println(n.lazyIntInDaHouse)
}

## gist:fe41dae3543c5f681c57
object ToFromMap {
  implicit def materialize[T]: ToFromMap[T] = macro impl[T]
  def impl[T: c.WeakTypeTag](c: Context): c.Expr[ToFromMap[T]] = {
    import c.universe._
    val wt = weakTypeOf[T]
    // Gets the type parameters, eg Holder[T, J] => List(T, J)
    val baseTypes = wt.baseClasses.head.asType.typeParams.map{ _.asType.toType }

    // Gives a Map(T -> Int, J -> Double) if we are extracting Holder[Int, Double]
    val myTypes = baseTypes zip wt.typeArgs toMap;

## gist:a222b99a7b689bde9585
class ext extends StaticAnnotation {
  def macroTransform(annottees: Any*) = macro extension.impl
}

object extension {
  def impl(c: Context)(annottees: c.Expr[Any]*): c.Expr[Any] = {
    import c.universe._
    annottees.map{ _.tree }.head match {
      case q"def $name[..$tp](...$params): $ret = $b" =>
        val Seq(Seq(thiz, rest @ _*), rest2 @ _*) = params