lshoo

use std::borrow::BorrowMut;
use std::ptr::replace;

pub fn do_sth() {

  test_merge_sort();
}

fn merge_sort(to_sort: &mut Vec<i32>, all: &mut Vec<i32>) {
    let len = to_sort.len();

lshoo

import shapeless.{:+:, ::, CNil, Coproduct, Generic, HList, HNil, Inl, Inr, Lazy}

/**
  * http://www.cakesolutions.net/teamblogs/solving-problems-in-a-generic-way-using-shapeless
  */
trait Depth[T] {
  def depth(t: T): Int
}

object Depth {

lshoo

def updateLiveStats(
                       time: Time,
                       liveId: String,
                           event: Option[Iterable[LiveEvent]],
                           state: State[LiveStatistics]
                          ): Option[LiveStatistics] = {

    event.flatMap { es =>
      val (creates, notCreates) = es.partition(_.isCreate)

lshoo

sealed trait KVStoreA[A]
case class Put[A](key: String, value: A) extends KVStoreA[Unit]
case class Get[A](key: String) extends KVStoreA[A]
case class Delete(key: String) extends KVStoreA[Unit]

import cats.free.Free
type KVStore[A] = Free[KVStoreA, A]

import cats.free.Free.liftF

lshoo

package utils

import org.joda.time.DateTime
import org.joda.time.format.{DateTimeFormatterBuilder, DateTimeFormat, DateTimeFormatter}

import scala.concurrent.stm._

/**
 * Created by liaoshifu on 2015/4/11
 */

lshoo

object SemiGroupApp {

  trait SemiGroup[T] {

    def append(a: T, b: T): T
  }

  /*object IntSemiGroup extends SemiGroup[Int] {
    def append(a: Int, b: Int) = a + b
  }*/

lshoo

package slicks.docs.dao

import scala.slick.driver.PostgresDriver.simple._
import scala.slick.driver._


trait Profile {
  val profile: JdbcProfile
}

lshoo

package neophyte.guide

import concurrent._
import ExecutionContext.Implicits.global
import neophyte.guide.PromiseFutures.TaxCut
import scala.util.{Failure, Success}

object PromiseFutures {

  case class TaxCut(reduction: Int)

lshoo

package programmingscala.Chapter09.jaxmagazine09
 
import concurrent.{Promise, ExecutionContext}
import scala.concurrent.duration._
 
import akka.actor._
import akka.pattern.ask
import akka.util.Timeout
import java.util.concurrent.TimeoutException
 

lshoo

package programmingscala.Chapter09.jaxmagazine09

import concurrent.{Promise, ExecutionContext}
import scala.concurrent.duration._

import akka.actor._
import akka.pattern.ask
import akka.util.Timeout
import java.util.concurrent.TimeoutException