mzimecki

def containsNeg1(nums: List[Int]) = nums.exists((x: Int) => x < 0)
def containsNeg2(nums: List[Int]) = nums.exists((x) => x < 0)
def containsNeg3(nums: List[Int]) = nums.exists(x => x < 0)
def containsNeg4(nums: List[Int]) = nums.exists(_ < 0)

mzimecki

import java.util.EnumSet;

/**
 * EnumSet uses natural order which means the order in which the enum constants are declared.
 */
public class EnumSetTest {
  
	private enum MyEnum {A, B, C, D}
	
	public static void main(String [] args) {

mzimecki

def and(x: Boolean, y: =>Boolean) = if (x) y else false
def or(x: Boolean, y: =>Boolean) = if (x) true else y

mzimecki

import scala.collection.immutable.HashMap
/**
 * hashCode and equals of mutable object (not working well because of object mutability)
 * the only way to make it working is to use immutable object
 */
class Point2(var x: Int, var y: Int) {
  def move(mx: Int, my: Int): Unit = {
    x = x + mx
    y = y + my
  }

mzimecki

object InsertionSort {

  def sort(list: List[Int]): List[Int] = {
    def insert(x: Int, xs: List[Int]): List[Int] = xs match {
      case List() => List(x)
      case y :: ys => if (x <= y) x :: xs else y :: insert(x, ys)
    }

    list match {
      case List() => List()

mzimecki

object MergeSort {

  def msort[T](xs: List[T])(implicit ord: Ordering[T]): List[T] = {

    def merge(xs: List[T], ys: List[T]): List[T] = (xs, ys) match {
      case (Nil, ys) => ys
      case (xs, Nil) => xs
      case (x :: xs1, y :: ys1) =>
        if (ord.lt(x, y)) x :: merge(xs1, ys) else y :: merge(xs, ys1)
    }

mzimecki

def max[T](xs: T*)(implicit ord: Ordering[T]): T = xs.reduceLeft((a, b) => if (ord.gteq(a, b)) a else b)

mzimecki

import FileWrapper.wrap

/**
 * Views example: converting one type to other.
 */
class FileWrapper(val file: java.io.File) {
  def /(next: String) = new FileWrapper(new java.io.File(file, next))
  override def toString = file.getCanonicalPath()
}

mzimecki

package com.zimek.executors;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

mzimecki

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

So you're curious in learning this new thing called (Functional) Reactive Programming (FRP).

Learning it is hard, even harder by the lack of good material. When I started, I tried looking for tutorials. I found only a handful of practical guides, but they just scratched the surface and never tackled the challenge of building the whole architecture around it. Library documentations often don't help when you're trying to understand some function. I mean, honestly, look at this:

Rx.Observable.prototype.flatMapLatest(selector, [thisArg])

Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.