weefbellington

import java.util.concurrent.TimeUnit;
import org.junit.Test;
import rx.Observable;
import rx.functions.Action0;
import rx.functions.Action1;
import rx.functions.Func1;
import rx.observers.TestSubscriber;

public class ReplayTest {

weefbellington

import org.junit.Test;

import java.util.concurrent.TimeUnit;

import rx.Observable;
import rx.functions.Func3;
import rx.schedulers.Schedulers;
import rx.subjects.PublishSubject;

/**

weefbellington

package com.dramafever.android.lib.rxjava;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

import rx.Subscriber;
import rx.functions.Action0;
import rx.functions.Action1;

weefbellington

import Debug.Trace

main :: IO()
main = do
  let sorted = bubbleSort [6, 5, 3, 1, 8, 7, 2, 4] :: [Integer]
  print sorted

bubbleSort :: (Ord a, Show a) => [a] -> [a]
--bubbleSort lst | trace ("sorting: " ++ show lst) False = undefined
bubbleSort [] = []

weefbellington

import Debug.Trace

main :: IO()
main = do
  let sorted = mergeSort [6, 5, 3, 1, 8, 7, 2, 4]
  print sorted

mergeSort :: (Ord a, Show a) => [a] -> [a]
-- mergeSort lst | trace ("sorting: " ++ show lst) False = undefined
mergeSort [] = []

weefbellington

import Data.Char
import Debug.Trace
import System.IO

main :: IO()
main = do
  hSetBuffering stdin NoBuffering
  putStrLn "Sample: counting words with a given letter"
  putStrLn "Input letter to count:"
  letter <- getChar

weefbellington

public class DataBindingComponent<DataType> implements Scene.Component {

    private final Bindable target;
    private final Data data;

    public DataBindingComponent(Data data, Bindable<DataType> target) {
        this.data = data;
        this.target = target;
    }

weefbellington

windowMap :: ( a -> a -> b) -> [a] -> [b]
windowMap func list =
    let zipped = zip list (tail list)
    in map (uncurry func) zipped

windowScan :: (b -> a -> a -> b) -> b -> [a] -> [b]
windowScan func accumulator list =
    let zipped = zip list (tail list)
        func' = \ acc -> uncurry (func acc)
    in scanl func' accumulator zipped

weefbellington

Promise<ResponseTypeA> responseA;
Promise<ResponseTypeB> responseB;

p1.then(new PromiseAction<A>() {
  public void call(A response) {
    // do something with the response
  }
});

p2.then(new PromiseAction<B>() {

weefbellington

Action1 onNext = new Action1<R>() {
  @Override
  public void call(R composedResult) {
    //do something
  }
};

Observable.zip(observable1, observable2,
  new Func2<T1, T2, R) {
    @Override