kevinadi

fold' :: (b->a->b) -> b -> [a] -> b
fold' f b [] = b
fold' f b (h:t) = fold' f (f b h) t

map' :: (a->b) -> [a] -> [b]
map' f lst = fold' (\b a -> b ++ [f a]) [] lst

map'' :: (a->b) -> [a] -> [b]
map'' f [] = []
map'' f (h:t) = f h : map'' f t

kevinadi

chunks :: Int -> [a] -> [[a]]
chunks _ [] = []
chunks n xs = (fst c) : chunks n (snd c)
    where c = splitAt n xs

chunks' :: Int -> [a] -> [[a]]
chunks' n = unfoldr (\b -> if null b then Nothing else Just (splitAt n b))

chunks'' :: Int -> [a] -> [[a]]
chunks'' n = takeWhile (not.null) . unfoldr (Just . splitAt n)

kevinadi

wordsWhen :: (Char -> Bool) -> String -> [String]
wordsWhen p s =  case dropWhile p s of
    "" -> []
    s' -> w : wordsWhen p s''
        where (w, s'') = break p s'

kevinadi

splitStr :: Eq a => [a] -> [a] -> [[a]]
splitStr sub str = split' sub str [] []
    where
    split' _   []  subacc acc = reverse (reverse subacc:acc)
    split' sub str subacc acc
        | sub `isPrefixOf` str = split' sub (drop (length sub) str) [] (reverse subacc:acc)
        | otherwise            = split' sub (tail str) (head str:subacc) acc

kevinadi

// MongoClient -- callbacks
var assert = require('assert')
var MongoClient = require('mongodb').MongoClient
MongoClient.connect('mongodb://localhost:27017/test', function(err,db) {
  assert.equal(null,err)
  console.log('connected')
  db.collection('test').find().toArray(function(err,res) {
    assert.equal(null,err)
    console.log(res)
  })

kevinadi

function random_pwd
  for i in (seq 5)
    cat /dev/urandom | env LC_CTYPE=C tr -dc 'a-zA-Z0-9' | fold -w 18 | head -n 1 | tr -d '\n' | fold -w 3 | tr '\n' '-'
    echo ''
  end
end

kevinadi

def unfoldr[A, B](seed: B)(func: B => Option[(A, B)]): Stream[A] =
  func(seed) match {
     case Some((a, b)) => a #:: unfoldr(b)(func)
     case None => Stream.empty
  }

/*
* Infinite sequence:
*   val s = unfoldr (0) (b => Some(b,b+1))
* Fibonacci sequence:

kevinadi

$ grep -R "::kStageType" *
src/mongo/db/exec/and_hash.cpp:const char* AndHashStage::kStageType = "AND_HASH";
src/mongo/db/exec/and_sorted.cpp:const char* AndSortedStage::kStageType = "AND_SORTED";
src/mongo/db/exec/cached_plan.cpp:const char* CachedPlanStage::kStageType = "CACHED_PLAN";
src/mongo/db/exec/collection_scan.cpp:const char* CollectionScan::kStageType = "COLLSCAN";
src/mongo/db/exec/count.cpp:const char* CountStage::kStageType = "COUNT";
src/mongo/db/exec/count_scan.cpp:const char* CountScan::kStageType = "COUNT_SCAN";
src/mongo/db/exec/delete.cpp:const char* DeleteStage::kStageType = "DELETE";
src/mongo/db/exec/distinct_scan.cpp:const char* DistinctScan::kStageType = "DISTINCT_SCAN";
src/mongo/db/exec/ensure_sorted.cpp:const char* EnsureSortedStage::kStageType = "ENSURE_SORTED";

kevinadi

-- Calculates distances between two points (a,b) and (x,y) on a great circle with radius r
-- Coordinates are in the form of (longitude,latitude)
--
-- Example: calculate distance between points (0,0) and (1,1) on earth:
--   ghci> geodist 6378.1 0 0 1 1
--   157.42462387232553
--
-- Result should be identical to MongoDB's $geoNear
--
-- Formula was taken from http://andrew.hedges.name/experiments/haversine/

kevinadi

var mongoBinary = {

    save : function(url, collection, filename) {

        var fs = require('fs')
        var Binary = require('mongodb').Binary
        var MongoClient = require('mongodb').MongoClient
        var assert = require('assert')

        var doc = {