Pandalang.org - How would a Panda program?

WARNING: Panda is a concept in progress, still changing and breaking...

You can try it out in the command line Interactive Panda.

(Other GUI oriented clients are being developed: panda touch, panda write, panda sheet)

Simple example

Take the numbers 1 to 10, keep the odd ones and then square them. Keep the squares less than 50!

Panda:

Details:

1..10 - the numbers 1 to 10 (function name 'to')
.odd - keep the odd
.sqr - just 'square' it!
.lt(50) - keep if 'lt' (less than) - ok sucky name!

Points:

We didn't need to give any types, they were obvious
No discussion what values we start with and if they are included
. - ok, this is just taking the previous value and connecting it to the function TODO: remove?
'odd' 'sqr' 'lt' - are names of functions, mapping directly to important concept in the problem description
No need for intermediate variables! (i, s)
Confused by the syntax? Most programmer are! Non-programmers are not...
"it looks like jquery"

Panda only has functions. A function can return several times. If it returns:

nothing - then the next function isn't called
one value - like a 'normal' function
several values - like a generator being automatically iterated over
sometimes - then it's asynchronious, like a callback

odd either returns nothing, or one value, if it's an odd integer. to is a generator, returning increasing integers each time

In this case we have use 4 functions:

1.to(10)->integer - to first returns 1. Then it returns 2. Then... 10.
integer.odd->integer - odd returns its argument if it's odd, otherwise nothing
integer.sqr-gt;integer - square returns the square of a integer
integer.lt(50)->integer - lt returns the value if it's less than the given value.

In plain old C - ala 1972


      #include 
        
      void main() {
        int i;
        for(i = 1; i <= 10; i++) {
          if (i % 2 == 1) {
            int s = i * i;
            if (s < 50)
              printf("%d ", s);
          }
        }
      }

Details:

#include <stdio.h> - why you need to tell it to know how to print? It's a computer, can't it print?
int i - i is assigned 1, it's an integer, so figure it out!
i - why it needs to named? i means what?
i <= 10 - up to including 10, however most loops start at 0 and use < boundary and +/- 1 bugs are very common
for( &nbpsp; ; &nbpsp; ; &nbpsp;) - interesting syntax '(' ';' ';' ')'
{ - start of "block"
i % 2 - modulo, fine it's an operator 'mod' may not be much clearer if you're programmer
== 1 - if the result is 1
i % 2 == 1 - wait a momement! What does this mean? if i dividided by 2 and the rest is 1... - ah ODD!
int s - again, we're telling the computer what to store "allocated 4/8 bytes"
s - oh, yeah, s is short for square, right...
i * i - simple definition of square
s < 50 clear, not including 50
printf - printf(ormatted), is there another print?
"%d " - print the following, an integer with no formatting(!) followed by one space
} } } - eh, ok, just checking your indentation, for you not to make mistakes

haskell - future ala 1990


      main = mapM (\v -> putStrLn (show v)) $
             filter (< 50) $
             map (\j -> j * j) $
             filter odd $
             let incr a = a : incr (a+1) in
             take 10 $
             incr 1

Details:

mapM - ok I'm mapM all day!
(\v -> ...) defining a function that takes a single parameter v
(putStr show v)) I'm putt'n a Str that I show'd you?
$ - dollar makes the world go around!
filter - am I filtering?
(< 50) - Ok, shorthand, reads fine-ish
$ - more money!
map - I'm mapping!
$ - I'm getting rich!
filter odd - filter odd - does that filter out or filter to keep?
let - basic let revived!
incr = a : incr (a+1) - a function 'incr' that given a number will return a list starting with it and continue with calling myself ('incr') with the next number (infinite lazy recursion)
in - given those lets, ok here comes the actual expression...
take 10 - yeah: give me 10 numbers
$ - why don't we just add a dollar to every line? (no we missed one...)
incr 1 - call the function 'incr' that we 'let' above with 1. It'll give 1,2,3...

Haskell list comprehension


      [s | i <-- [1..10], odd i, let s = i * i, s < 50]

That's cool! However, still..

[ ... ] - returning a list
s - return s. What s?
| - bar... but these...
i - we have to name them something (why?)
<- - forward assignment from list implying... a loop?
[1..10] - another list (comprehension) with special syntax gives numbers 1 to 10
, - ok another item coming, of expressions
odd i - a guess it's an implied filter predicate if it returns boolean?
let - OK, can't say s <- on single value, how come I need no "in"? and it's avaible above the let? what's the scope of this thing?
s < 50 - implicit filter on each value of i/s, ok if s less than 50

PandaBETA

Simple example

Panda:

In plain old C - ala 1972

haskell - future ala 1990

Haskell list comprehension

Panda^BETA