mjgpy3

_.flow(
  _.castArray,
  _.partial(_.at, _, ['[0].id', '[0]']),
  _.spread(put)
)

mjgpy3

Prelude

T1: B = (\f g x. f (g x))

Goal

(B a (B b c)) = (B (B a b) c)

mjgpy3

var filter = function (xs, p) {
  return xs.reduce(function (results, v) {
    return results.concat(p(v) ? [v] : []);
  }, []);
};

var map = function (xs, f) {
  return xs.reduce(function (results, v) {
    return results.concat([f(v)]);
  }, []);

mjgpy3

foo.py  select-column.py                                                                                                                                                                                                                                                                                                                                                                                                                                                                  X
values = [
  [1, 10, 20, 30, 40],
  [2, 10, 21, 31, 41],
  [3, 11, 22, 32, 42],
  [4, 10, 23, 33, 43],
]

def matches_10(row):
  return row[1] == 10

mjgpy3

from itertools import groupby

values = [
  ['1', 'r1', '100'],
  ['1', 'r2', '100'],
  ['1', 'r3', '105'],
  ['1', 'c1', '100']
]

def grouping_factor(row):

mjgpy3

def group_by(values, grouping_factor):
  results = {}

  for value in values:
    key = grouping_factor(value)

    if key in results:
      results[key].append(value)
    else:
      results[key] = [value]

mjgpy3

print "hello world"

""" This is a multi-line comment... no it's not
int main() {
  return 0;
}
"""

def main():
  return 0

mjgpy3

type Person(name: string) =
  member this.GetName () = name

type Employee(name: string, id: int) =
  inherit Person(name)

  member this.GetId () = id

  member val Id = id with get, set

mjgpy3

function Unstyled() {
  this.append = function (other) {
    return other;
  };

  this.empty = function () {
    return new Unstyled();
  };

  this.$addLesserStyle = function (style, value) {

mjgpy3

myPlusCommutes : (n : Nat) -> (m : Nat) -> n + m = m + n
myPlusCommutes Z Z = Refl
myPlusCommutes Z (S k) = rewrite plusZeroRightNeutral (S k) in Refl
myPlusCommutes (S k) Z = rewrite plusZeroRightNeutral (S k) in Refl
myPlusCommutes (S k) (S j) =
  cong {f=S} (rewrite sym (plusSuccRightSucc k j) in (rewrite myPlusCommutes k j in (rewrite plusSuccRightSucc j k in Refl)))