/var/log/mind

state of the lambda

1
2
3
4
5
6

List<String> result =  Arrays.asList("Larry", "Moe", "Curly")
                              .stream()
                              .map(s -> "Hello " + s)
                              .collect(Collectors.toList());

// result will be a List<String> containing "Hello Larry", "Hello Moe" and "Hello Curly"

1
2
3
4
5
6

IntStream str1 = Streams.intRange(1,10);
IntStream str2 = Streams.intRange(21,30);
Stream<Integer> joined = Streams.concat(str1.boxed(), str2.boxed());
System.out.println(joined.collect(Collectors.toList()));

// Expected output : [1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 28, 29]

1
2
3
4
5

Stream<Integer> ints = Streams.intRange(0,5).boxed();
Stream<String> strs = Arrays.asList("foo", "bar", "baz", "qux").stream();
System.out.println(Streams.zip(ints,strs, (i, s) -> i.toString() + s).collect(Collectors.toList()));

// Expected output: ["0foo", "1bar", "2baz", "3qux"]

1
2
3
4
5
6
7
8

Stream<String> strings;
strings.map(
    new MapperFunction<String,String>() {
        public String map(String str) {
            return "Hello" + str;
        }
    }
);

1
2
3
4
5

Arrays.asList(1,2,3,4,5,6)
      .stream()
      .map(n -> n * n) // square the number
      .map(n -> n + 3) // add 3 to the value
      .reduce(0, (i, j) -> i + j)); // add the number to the accumulator

1
2
3
4
5
6

List<String> result =  Arrays.asList("Larry", "Moe", "Curly")
                              .stream()
                              .map(s -> "Hello " + s)
                              .collect(Collectors.toList());

// result will be a List<String> containing "Hello Larry", "Hello Moe" and "Hello Curly"

1

print map(lambda x: x * 2, range(1,11))

1

print sum(range(1,1001))

1
2
3
4

wordlist = ["scala", "akka", "play framework", "sbt", "typesafe"]
tweet = "This is an example tweet talking about scala and sbt."

print map(lambda x: x in tweet.split(),wordlist)

1

print open("ten_one_liners.py").readlines()

1

print map(lambda x: "Happy Birthday to " + ("you" if x != 2 else "dear Name"),range(4))

1

print reduce(lambda(a,b),c: (a+[c],b) if c > 60 else (a,b + [c]), [49, 58, 76, 82, 88, 90],([],[]))

1
2
3
4

from xml.dom.minidom import parse, parseString
import urllib2
# note - i convert it back into xml to pretty print it
print parse(urllib2.urlopen("http://search.twitter.com/search.atom?&q=python")).toprettyxml(encoding="utf-8")

1
2

print min([14, 35, -7, 46, 98])
print max([14, 35, -7, 46, 98])

1
2
3
4

import multiprocessing
import math

print list(multiprocessing.Pool(processes=4).map(math.exp,range(1,11)))

1
2
3

n = 50 # We want to find prime numbers between 2 and 50

print sorted(set(range(2,n+1)).difference(set((p * f) for p in range(2,int(n**0.5) + 2) for f in range(2,(n/p)+1))))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

case class Meme (var catchPhrase : String,  var url: String)

// Notice: class members are declared as default constructor parameters. No further
//         declaration required again.
class MemeAdvanced (private [this] var cp: String, private [this] var u: String){
  // Since these are private fields, they can be wrapped using 
  // getters / setters as follows which can be modified to suit any non-typical
  // expectations eg. validations

  // if the above parameter declarations did not have private qualifier,
  // the methods below would be automatically provided, whereas if declaration contained
  // val instead of var, only the getter would get provided.
  def catchPhrase = cp
  def catchPhrase_=(s: String) {cp = s}

  def url = u
  def url_=(s: String) { u = s}
}

object DoubleRainbow {

  def main(args : Array[String]) : Unit = {
    // using case classes
    var meme = new Meme("foo","bar")
    meme.catchPhrase = "Rick roll'd"
    meme.url = "http://www.youtube.com/watch?v=EK2tWVj6lXw"
    println(meme.catchPhrase)

    // using normal classes
    var meme2 = new MemeAdvanced("foo","bar")
    meme2.catchPhrase = "Rick roll'd"
    meme2.url = "http://www.youtube.com/watch?v=EK2tWVj6lXw"
    println(meme.catchPhrase)
  }
}

1
2

var meme = new Meme(catchPhrase="blub", url="blub2")
println(meme.catchPhrase)

1

val digits = List[Int](0,1,2,3,4,5,6,7,8,9)

1
2

val keywordsMapping = Map[String,String] ( "super" -> "base", "boolean" -> "bool", "import" -> "using" )
println(digits.head + " " + keywordsMapping("boolean"))

1
2
3

val input = """Multiline
                      325-532-4521"""
println(input)

1
2
3
4
5
6
7
8
9
10
11

// declare a function pointer which takes a string as an input
// and outputs the same
var normalizeOp = (input: String) => input reverse;
println(normalizeOp("abcd"))

// compiler error : normalizeOp = (input: String) => 0;
// thus the type of normalizeOp can no longer be changed

// but it can be used to point to a different method instead
normalizeOp = (input: String) => input trim;
println(normalizeOp("  foo  bar  "))

1
2
3
4
5
6
7

class Event {
  var l = List[() => Unit]()

  def +=(f: () => Unit): Unit = l = f :: l

  def apply() = l map (_())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Button {
  val action = new Event();

  def performClick() = onClick()

  private def onClick() = {
    // this should call the apply() method
    action()
  }
}

object EventDriver {
  def performAction() {
    println("Work!")
  }

  def main(args : Array[String]) : Unit = {
    val button = new Button()
    // add a method as a listener
    button.action += performAction
    // trigger the event
    button.performClick()
  }
}

1
2
3

def isUniverseAnswer = (x: Int) => x == 42
println(isUniverseAnswer(42))
println(isUniverseAnswer(43))

1
2
3
4
5

val users = List[User](User("Five",5), User("Fifteen",15), User("TwentyFive", 25),
                      User("Ten",10), User("Twenty", 20))
// Note : the argument passed to the filter() method is the lambda, and the _ refers 
//           to each User object passed in
println (users filter (_.age < 18))

1
2
3
4

var counter = 0
val action = () => {counter += 1; println("counter = " + counter)}
action()
action()

1

println("Example" reverse)

1
2
3
4
5
6
7
8
9

object ReturnMultiple {
  // this method returns two values
  def addOneToAll(a: Int, b: Int) = (a + 1, b + 1)

  def main(args : Array[String]) : Unit = {
    val (c, d) = addOneToAll(3,4)
    println(c + "," + d)
  }
}

1

string result = a ?? b ?? c

1
2
3
4
5
6
7
8
9
10
11
12
13

class Nullable(val t: AnyRef) {
    def ??(b: AnyRef) = if (this.t != null) this.t else b
}

object NullCoalescing {
  implicit def objToNullable(a: AnyRef) : Nullable = { new Nullable(a) }

  def main(args : Array[String]) : Unit = {
    println("hello" ?? null ?? null)
    println((null: AnyRef) ?? "world" ?? null)
    println((null: AnyRef) ?? null ?? "foobar")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import java.io.FileInputStream
import java.io.DataInputStream
import java.io.InputStreamReader
import java.io.BufferedReader
object AutomaticResourceManagement {
  // This is a structural type. Any type which has methods which match the two
  // desired signatures specified below can be used wherever this type is expected
  // ** no inheritance required **
  type ReadableAndCloseable = { def close(): Unit ; def readLine() : String}

  // And to be able to define our own control structure, the second parameter to
  // using takes a function block which takes a ReadableAndCloseable as input
  // and returns nothing.
  def using(resource: ReadableAndCloseable)(f: ReadableAndCloseable => Unit) {
    try {
      f(resource)
    } finally {
      println("Closing resource")
      resource.close()
    }
  }

  def main(args : Array[String]) : Unit = {
    val reader = new BufferedReader(new InputStreamReader(new DataInputStream(new FileInputStream("foo.txt"))))
    // Now you can be sure, the reader will get closed.
    using(reader){
      (resource) => println("First line is: " + resource.readLine())
    }
  }
}

1
2
3
4
5
6
7
8
9
10

import zipfile
from lxml import objectify
from operator import itemgetter
import itertools

# Unzip file, extract xml, convert to object    
zip = zipfile.ZipFile("../cia-1996.zip")
xmlfile = zip.open("cia-1996.xml")
root = objectify.fromstring("".join(line for line in xmlfile.readlines()))
zip.close()

1
2
3
4
5
6
7
8
9

# Country with highest population
maxp = 0
maxc = ''
for country in root.country :
    if int(country.get('population',0)) >= maxp :
        maxc, maxp =country.get('name'),int(country.get('population',0))
print (maxc,maxp)

# Output is : ('China', 1210004956)

1
2
3
4
5
6
7
8

# Top 5 countries with highest inflation rates
inflation_country_tuples = []
for country in root.country :
    inflation_country_tuples.append((float(country.get('inflation',0.0)), country.get('name')))
inflation_country_tuples = sorted(inflation_country_tuples, key=itemgetter(0), reverse=True)
print inflation_country_tuples[0:5]

# Output : ((244.0, 'Belarus'), (94.0, 'Turkey'), (85.0, 'Azerbaijan'), (83.299999999999997, 'Malawi'), (71.299999999999997, 'Yemen'))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# Countries by continent
continent_country_tuples = []
for country in root.country :
    continent_country_tuples.append((country.get('continent',''), country.get('name')))
continent_country_tuples = sorted(continent_country_tuples)
current_continent = None
countries_of_continent = None
continent_grouped_countries = []
for continent, country in continent_country_tuples :
    if continent != current_continent :
        if current_continent :
            continent_grouped_countries.append((current_continent, countries_of_continent))
        countries_of_continent = []
        current_continent = continent
    countries_of_continent.append(country)
continent_grouped_countries.append((current_continent, countries_of_continent))
print continent_grouped_countries

# Output : too long to include here

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# Country with highest population
print reduce(lambda (maxc,maxp), c :
             (c.get('name'),int(c.get('population',0)))
                if int(c.get('population',0)) >= maxp else
                    (maxc,maxp),
             root.country,('',0))

# Top 5 countries with highest inflation rates
print tuple(itertools.islice(
            sorted((
                (float(country.get('inflation',0.0)), country.get('name'))
                        for country in root.country),
                key=itemgetter(0),reverse=True),
                5))

# Countries by continent
print tuple((continent,tuple(country[1] for country in countries))
        for continent, countries in itertools.groupby(
            sorted((country.get('continent',''), country.get('name'))
                    for country in root.country),itemgetter(0)))

1
2
3
4
5
6
7
8
9
10

# Find the country with the maximum population
print reduce(lambda country_pop_max, country_pop_next : country_pop_next if country_pop_next[1] > country_pop_max[1] else country_pop_max,
        map(lambda country : (country.get('name'), int(country.get('population', 0))),root.country),('',0))

print tuple(itertools.islice(sorted(
            map(lambda country : (country.get('name'), float(country.get('inflation', 0.0))),root.country),
            key=itemgetter(1),reverse=True),5))

print map(lambda (continent, continent_country_tuples) : (continent, map(lambda (continent, country) : country, continent_country_tuples)),
    itertools.groupby(sorted(map(lambda country : (country.get('continent'), country.get('name')),root.country)),itemgetter(0)))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

print reduce(
        # Comparator to decide the country with the maximum population
        lambda country_pop_max, country_pop_next : country_pop_next if country_pop_next[1] > country_pop_max[1] else country_pop_max,
        # get a sequence of tuples of (country name, country population)    
        map(lambda country : (country.get('name'), int(country.get('population', 0))),root.country),
        # initial seed
        ('',0))

print tuple(
        # take the top 5 items
        itertools.islice(
            # sort the list
            sorted(
                # get a sequence of tuples of (country name, inflation)   
                map(lambda country : (country.get('name'), float(country.get('inflation', 0.0))),root.country),
                # sorting to be done using the second element of the tuple
                key=itemgetter(1),
                # sort to be done in the descending order
                reverse=True),
            # count of elements to be sliced
            5))

print map(
    # function to flatten the continent_country_tuple tuple into a country tuple      
    lambda (continent, continent_country_tuples) :
        # first element of the tuple is continent
        (continent,
        # as the second element, return only the country from the continent country tuple to form a tuple of countries                                        
        map(lambda (continent, country) : country, continent_country_tuples)),
    # group the continent country tuples by continent
    itertools.groupby(
        # sort the continent country tuples
        sorted(
            # extract a continent country tuple from the country
            map(lambda country : (country.get('continent'), country.get('name')),root.country)),
        # this is the function to extract the key to sort by
        itemgetter(0)))

1
2
3
4
5

def twice(val): return str(2 * val)

print map(twice,(1,2,3,4,5))

#Expected output is :['2', '4', '6', '8', '10']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# Declare the class
class Person(object):
    """ A person. Has a name and an age"""
    def __init__(self,name,age):
        self.name = name
        self.age = age

# Instantiate the objects
jimmy = Person("Jimmy",5)
alex = Person("Alex",36)
edna = Person("Edna",99)

# Run the multi method
print name(jimmy)
print name(alex)
print name(edna)

#Expected output is 
#        Young Jimmy
#        Adult Alex
#        Senior Edna

1
2
3
4
5

def ticket(person):
    """ The switcher function to decide the result to be used for multi method switching """
    if person.age < 16 : return "young"
    elif person.age >= 66 : return "senior"
    else : return "adult"

1
2

# Declare the existence of a multi method switcher
name = multi(ticket)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Add the first switched function for result value "young"
@multi_method(name, "young")
def name(person):
    return "Young " + person.name

# Add the next switched function for the result value "adult"
@multi_method(name, "adult")
def name(person):
    return "Adult " + person.name

# Add yet another switched function for the result value "senior"
@multi_method(name, "senior")
def name(person):
    return "Senior " + person.name

1
2
3
4
5
6
7
8
9
10
11
12
13

def multi(switcher_func):
    """ Declares a multi map based method which will switch to the
    appropriate function based on the results of the switcher func"""

    def dispatcher(*args, **kwargs):
        key = switcher_func(*args, **kwargs)
        func = dispatcher.dispatch_map[key]
        if func :
            return func(*args,**kwargs)
        else :
            raise Exception("No function defined for dispatch key: %s" % key)
    dispatcher.dispatch_map = {}
    return dispatcher

1
2
3
4
5
6
7
8
9
10

def multi_method(dispatcher, result):
    """ The multi method decorator which allows one method at a time
    to be added to the broader switch for the given result value"""
    def inner(wrapped):
        dispatcher.dispatch_map[result] = wrapped
        # Change the method name from clashing with the multi and allowing
        # all multi methods to be written using the same name
        wrapped.func_name = "_" + wrapped.func_name + "_" + str(result)
        return dispatcher
    return inner

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Person(object):
    """ A person. Has a name and an age"""
    def __init__(self,name,age):
        self.name = name
        self.age = age

    __str__ = multi(ticket)

    @multi_method(__str__,"young")
    def str_young(self):
        return "Young " + self.name

    @multi_method(__str__,"adult")
    def str_adult(self):
        return "Adult " + self.name

    @multi_method(__str__,"senior")
    def str_senior(self):
        return "Senior " + self.name

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

def multi():
    """ Declares a multi map based method which will switch to the
    appropriate function based on the results of the switcher func"""

    def dispatcher(*args, **kwargs):
        for condition, func in dispatcher.functions :
            if condition(*args, **kwargs) :
                return func(*args,**kwargs)
        raise "No function identified for dispatch key"

    dispatcher.functions = []
    return dispatcher

def multi_method(dispatcher, condition):
    """ The multi method decorator which allows one method at a time
    to be added to the broader switch for the given result value"""
    def inner(wrapped):
        dispatcher.functions.append((condition, wrapped))
        # Change the method name from clashing with the multi and allowing
        # all multi methods to be written using the same name
        wrapped.func_name = "_" + wrapped.func_name + "_" + str(condition)
        return dispatcher
    return inner

class Person(object):
    """ A person. Has a name and an age"""
    def __init__(self,name,age):
        self.name = name
        self.age = age

# Declare the existence of a multi method switcher
name = multi()

# Add the first switched function for result value "young"
@multi_method(name, lambda p : p.age < 16)
def name(person):
    return "Young " + person.name

# Add the next switched function for the result value "adult"
@multi_method(name, lambda p : 16 <= p.age < 66)
def name(person):
    return "Adult " + person.name

# Add yet another switched function for the result value "senior"
@multi_method(name, lambda p : 66 <= p.age)
def name(person):
    return "Senior " + person.name

# Instantiate the objects
jimmy = Person("Jimmy",5)
alex = Person("Alex",36)
edna = Person("Edna",99)

# Run the multi method
print name(jimmy)
print name(alex)
print name(edna)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

(defmulti encounter (fn [x y] [(:Species x) (:Species y)]))
(defmethod encounter [:Bunny :Lion] [b l] :run-away)
(defmethod encounter [:Lion :Bunny] [l b] :eat)
(defmethod encounter [:Lion :Lion] [l1 l2] :fight)
(defmethod encounter [:Bunny :Bunny] [b1 b2] :mate)
(def b1 {:Species :Bunny :other :stuff})
(def b2 {:Species :Bunny :other :stuff})
(def l1 {:Species :Lion :other :stuff})
(def l2 {:Species :Lion :other :stuff})
(encounter b1 b2)
-> :mate
(encounter b1 l1)
-> :run-away
(encounter l1 b1)
-> :eat
(encounter l1 l2)
-> :fight

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# Declare the existence of a multi method switcher
encounter = multi(lambda x,y : (x["Species"], y["Species"]))

@multi_method(encounter, ("Bunny","Lion"))
def encounter(a1, a2):
    return "run-away"

@multi_method(encounter, ("Lion","Bunny"))
def encounter(a1, a2):
    return "eat"

@multi_method(encounter, ("Bunny","Bunny"))
def encounter(a1, a2):
    return "mate"

@multi_method(encounter, ("Lion","Lion"))
def encounter(a1, a2):
    return "fight"

b1 = {"Species" : "Bunny", "Other" : "Stuff"}
b2 = {"Species" : "Bunny", "Other" : "Stuff"}
l1 = {"Species" : "Lion", "Other" : "Stuff"}
l2 = {"Species" : "Lion", "Other" : "Stuff"}

print encounter(b1, b2)
print encounter(b1, l1)
print encounter(l1, b1)
print encounter(l1, l2)

1
2
3
4

mate
run-away
eat
fight

1
2
3

one_to_five = [1,2,3,4,5]
for num in one_to_five :
    print num

1
2
3
4
5
6
7
8
9

d = {1:"One", 2: "Two", 3:"Three"}
# keys
for val in d : print val
# an alternative for keys
for val in d.keys() : print val
# values
for val in d.values() : print val
# key, value tuples
for key,val in d.items() : print key, val

1
2
3
4
5
6
7
8
9
10

seq=[0,1,2,3,4,5,6,7]

#first 3
print seq[:3]
# last 3
print seq[-3:]
# 2nd to second last
print seq[1:-1]
# reverse the sequence
print seq[::-1]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# An iterator object to sequentially offer the next number
# in a sequence. Raises StopIteration on reaching the end
class RangeIterator(object):
    def __init__(self,begin,end):
        self._next = begin - 1
        self.end = end
    def next(self):
        self._next += 1
        if self._next < self.end :
            return self._next
        else :
            raise StopIteration

# A class which allows sequential iteration over a range of
# values (begin inclusive, end exclusive)
class Range(object):
    def __init__(self,begin,end):
        self.begin = begin
        self.end = end
    def __iter__(self):
        return RangeIterator(self.begin, self.end)

oneToFive = Range(1,5)

1
2
3
4
5

for number in oneToFive :
    print 'Next number is : %s' % number

print 'Is 2 in oneToFive', 2 in oneToFive
print 'Is 9 in oneToFive', 9 in oneToFive

1
2
3
4
5
6

Next number is : 1
Next number is : 2
Next number is : 3
Next number is : 4
Is 2 in oneToFive True
Is 9 in oneToFive False

1
2
3
4
5
6
7
8
9
10
11

def my_range(begin, end):
    current = begin
    while current < end :
        yield current
        current += 1

for number in my_range(1,5) :
    print 'Next number is : %s' % number

print 'Is 2 in oneToFive', 2 in my_range(1,5)
print 'Is 9 in oneToFive', 9 in my_range(1,5)

1
2
3
4

# A list comprehension that returns even numbers between 0 and 9
even_comprehension = (num for num in range(10) if num % 2 == 0)
print type(even_comprehension)
print tuple(even_comprehension)

1
2

type 'generator'
(0, 2, 4, 6, 8)

1
2

def square(num): return num * num
print tuple(map(square,range(5)))

1

(0, 1, 4, 9, 16)

1

print tuple(map(lambda num : num * num,range(5)))

1

print filter(lambda x : x % 2 == 0, range(5))

1

[0, 2, 4]

1

print reduce(lambda reduced,num : reduced + (num * num), range(5), 0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#map
seq = []
for num in range(5) :
    seq = seq + [num * num]
print seq

#filter
seq = []
for num in range(5) :
    if num % 2 == 0 :
        seq = seq + [num]
print seq

#reduce
total = 0
for num in range(5) :
    total = total + (num * num)
print total

1
2
3
4
5

from collections import namedtuple

Context = namedtuple('Context','stack, current, op')
def default_context():
    return Context([],0.0,None)

1
2
3
4
5
6

def add(x,y): return x + y
def sub(x,y): return x - y
def mult(x,y): return x * y
def div(x,y): return x/ y
def reverse_sign(x): return -1 * x
def pow(x,y): return x ** y

1
2
3
4

otheradd = add
add = sub
assert otheradd(7,3) == 10
assert add(7,3) == 4

1
2
3

from functools import partial

square = partial(pow,y=2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

unary_functions = {'!' : reverse_sign, '@' : square }

def handle_unary_op(ctx,x):
    return ctx._replace(current = unary_functions[x](ctx.current), op = None)

binary_functions = {'+' : add, '-' : sub, '*' : mult, '/' : div}

def handle_binary_op(ctx,x):
    return ctx._replace(op = binary_functions[x])

def handle_float(ctx,x):
    if not ctx.op :
        return ctx._replace(current = x)
    else :
        return ctx._replace(current = ctx.op(ctx.current,x), op = None)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def start_brace(ctx):
    newstack = ctx.stack
    newstack.append((ctx.current,ctx.op))
    return ctx._replace(
                stack = newstack,
                current = 0.0, op = None)

def end_brace(ctx):
    stack = ctx.stack
    current = ctx.current
    oldcurrent, oldop = stack.pop()

    oldctx = Context(stack,oldcurrent,oldop)
    return process_key(oldctx,current)

tokens = { '(': start_brace, ')' : end_brace}

def handle_tokens(ctx,x):
    return tokens[x](ctx)

1
2
3
4
5
6
7
8
9
10
11
12
13

function_groups = {
    tuple(unary_functions.keys()) : handle_unary_op,
    tuple(binary_functions.keys()) : handle_binary_op,
    tuple(tokens.keys()) : handle_tokens
}

def process_key(ctx,key):
    if isinstance(key,(types.FloatType,types.IntType, types.LongType)) :
        return handle_float(ctx,key)
    elif isinstance(key,(types.StringType)) :
        for function_class in function_groups :
            if key in function_class : return function_groups[function_class](ctx,key)
    return ctx

1
2

def process_keys(keys):
    return reduce(lambda ctx,key : process_key(ctx,key), keys, default_context())

1
2
3
4
5

def process_keys(keys):
    ctx = default_context()
    for key in keys :
        ctx = process_key(ctx,key)
    return ctx

1
2
3
4
5
6

if __name__ == "__main__" :
    assert process_keys((2,'+', 3)).current == 5
    assert process_keys((2, '!', '+', 5)).current == 3
    assert process_keys((2, '@')).current == 4
    assert process_keys((2,'+',3,'*',5)).current == 25
    assert process_keys((2,'+','(',3,'*',5,')')).current == 17

1
2
3
4
5
6
7
8
9
10

from itertools import chain

def plus_num_seq(n):
    count = 1
    while count <= n :
        yield '+', count
        count += 1

keys = list(chain.from_iterable(plus_num_seq(10)))[1:]
assert process_keys(keys) == 55

Method	Description
allMatch	true if all elements of the stream match the predicate
anyMatch	true if any element of the stream match the predicate
filter	return a stream of subset of the elements matching the predicate
findAny	return an element of the stream matching the predicate
findFirst	return the first element of the stream matching the predicate
flatMap	Return a stream where each input element is transformed into 0 or more values
flatMap	Return a stream where each input element is transformed into a stream
forEach	Perform an operation on each element of the stream (usually for side effects)
limit	Return a stream with no more than the first maxSize elements of this stream
map	Transform the stream into another containing the results after applying the function mapper on each element of the stream
max	Return the maximum element of this stream based on the supplied comparator
min	Return the minimum element of this stream based on the supplied comparator
peek	Return the same stream even as the elements are also provided to the consumer
reduce	Reduce the stream to a single value, performing the reducer operation on each element along with the accumulated value (accumulated value starting with the identity).
sorted	Sort the stream based on natural order or supplied comparator
subStream	Return a stream after discarding the first startingOffset elements (and those after optionally provided endingOffset elements)
toArray	Convert stream to array

/var/log/mind

Exploring Java8 Lambdas. Part 1

Information :

Motivation :

Whither Java Collections Framework

Implementation used in this post

Typical pipeline structure.

Streams

Stream

Functions

Functional Interfaces

Collectors

Pending topics :

Why OSGi? Or why not using it makes your JVM runtime unsafe.

The OSGi way :

The JVM runtime by default is unsafe

Library Vendors : Please make your jars OSGi compatible

Conference Report - Hasgeek jsFoo Pune 2012

Scala needs terraces

Which risk would you manage? What would you want to prove? Programming Languages

Contrasting Performance : Languages, styles and VMs - Java, Scala, Python, comments: true Erlang, Clojure, Ruby, Groovy, Javascript

Why you should register to attend Python Conference Pune (Sept 2011) right

Google Plus : Getting close to the sweet spot by getting the basics right

10 Python one liners to impress your friends

Why Java folks should look forward to Scala

The cloud just got stronger, even as AWS went down

Code Kata : Ruby Programming Challenge for Newbies in Python

Monads in an Object Oriented context

A case for non leaky dual abstractions.

Clojure style multi methods in python

Programming Languages should be Simple (or My ideal programming language)

Presentation : Recent trends in technology

Double whammy. The state and dilemma of Indian IT

Functional Programming with Python – Part 2 - Useful python constructs

Functional Programming with Python - Part 1