fuckyeahterminals

I’m gonna explain this to you very simply and very intuitively so that you understand. I didn’t realize people didn’t understand this until I was auditing a UCI seminar as a potential college for a CS Masters in Robotics.

While I was there I heard an erroneous conversation about how lambda’s work. So let’s start with an example…

 filter (lambda x : x != '',  map(lambda x : ' '.join(x.split()), hxs.select('//td/text()').extract()))  

ok, this is how something like this reads. Remember filter filters on that which return false.

For every x in the collection (that is to say for every x in my array, set, whatever), add x to the resulting set if x != “”, return it by default when you’re done operating filter.

so in Java or whatever fucking pansy-ass language you like, it would look something like this

String [] someArray = someBullshitHere;
ArrayList<String> result = new ArrayList<String>();
for(String s : someArray)
{
   if (!s.equals(""))
   {
      result.append(s);
   }
}
return result;

See How Verbose that is? fuck that shit plus I can’t nest it. I mean you wanna see what that nested python statement would look like nested in Java?

private ArrayList<T> outerMost(ArrayList<T> originalScrape)
{
   return second(first(originalScrape));
}
private ArrayList<T> first(ArrayList<T> someInput)
{
   delimiter = "Whatever The Fuck You Need";
   newDelimiter = "Whatever Gives you a Hard-On";
   ArrayList<T> result = new ArrayList<T>();
   for(T t :  someInput)
   {
      result.append(helperJoin(t.split(delimiter), newDelimter));
   }
}
private T helperJoin (T [] input, T Delim)
{
   T result = blankCreationOfT();
   for (T t : in input)
   {
      result.yourJoinDef(t.yourJoinDef(delim));
   }
   return result;
}
private ArrayList<T> second(ArrayList<T> someInput)
{
   ArrayList<T> result = new ArrayList<T>();
   for (T t : someInput)
   {
      if (t.someFuckingComparatorIHaveToWriteAgainstString(""))
      {
         result.append(t);
      }
   }
   return t;
}

Whew! FUCK THAT. You see how terse it is? It’s not even a halfway good implementation, I’ve already spend 10 more min that I wanted to trying to get a fully generic solution which is what python is giving me. And there are a few of you smart-asses that’ll be like “Well they added that to the language now, lambda expressions are a go-go”

That’s exactly right “THEY ADDED IT,” they dropped a steamy shiny turn onto the language that was already a FAT turd to begin with. And if you don’t think adding someshit on, vs making part of the language when you design the language, makes a difference Read the Dragon book, write a Front-End Compiler, then we’ll talk, then I’ll listen to you try and make a case.

So when using lambda expression is just a very nice, very powerful way of saying in a short-hand way hey for this type of input coming in I want you to operate on it in this way for every element in that input that’s all it is, then it’s up to you to decide how it gets processed.

foldl (\x y -> x + y) 0 [1..10]

That’s in Haskell, where foldl for you non-haskell fold, is equivalent to python’s reduce function. So do you see what I’m doing here, I’m saying hey reduce this with this lambda expression. your base case is 0 and your input array is elements 1 to 10. This is ACTUAL Haskell code btw, if you dump this on the ghci it will run. it ain’t short-hand for nothing, actually it’s too verbose. It should say.

fold (+) 0 [1..10]

Anyway…</rant> case and point, don’t talk about shit you don’t know about, just ‘cuz you’re going to what you think is a swanky college. Which it ain’t btw, the speaker was some dude who was doing distributed computing on phones. Motherfucker, Hadoop+Client on Phone+Correct Config = What you did with Significantly less Effort. Also, Motherfucker MongoDB if you’re gonna implement a twitter wrapper and expect it to scale.