lrvick

 app.controller( 'AppCtrl', function ($scope, socket) {
    socket.onopen(
        function(){
            console.log('Socket is connected :D')
        }
    )
    socket.onclose(
        function(){
            console.log('Socket is disconnected :(')
        }

vmarquez

    //Reader Monad and its extension class to give it SelectMany(bind/flatMap) capabilities for use in LINQ queries
    public static class ReaderMonadExt
    {
        public static ReaderMonad<T, C> SelectMany<T, A, B, C>(this ReaderMonad<T, A> rm, Func<A, ReaderMonad<T, B>> bindf, Func<A, B, C> select)
        {
            return new ReaderMonad<T, C>(t =>
            {
                var a = rm.Run(t);
                return select(a, bindf(a).Run(t));
            });

koddo

;; for Coursera / Programming Languages
;; in emacs sml-mode: single keystroke for restarting repl and loading current file
(require 'cl)
(add-hook 'sml-mode-hook
          (lambda ()
            (define-key sml-mode-map (kbd "C-c C-v") 'my-sml-restart-repl-and-load-current-file)
            (defun my-sml-restart-repl-and-load-current-file ()
              (interactive)
              (ignore-errors (with-current-buffer "*sml*"
                               (comint-interrupt-subjob)

hyone

{-# LANGUAGE FlexibleContexts #-}

import Data.Conduit
import qualified Data.Conduit.List as CL
import Network.HTTP.Conduit

import Control.Concurrent.Async (mapConcurrently)
import Control.Concurrent.MVar
import Control.Monad.IO.Class (liftIO)
import Control.Monad.Trans.Control (MonadBaseControl)

richhickey

(defmacro test->
  "Takes an expression and a set of test/form pairs. Threads expr (via ->)
  through each form for which the corresponding test expression (not threaded) is true."
  [expr
  & clauses]
  (assert (even? (count clauses)))
  (let [g (gensym)
        pstep (fn [[test step]] `(if ~test (-> ~g ~step) ~g))]
    `(let [~g ~expr
           ~@(interleave (repeat g) (map pstep (partition 2 clauses)))]

ztellman

(ns dojo.core
  (:require
    [clojure.string :as str]))

;;;

(def digits
  [[" _ " "| |" "|_|"]
   ["   " "  |" "  |"]
   [" _ " " _|" "|_ "]

channingwalton

object KleisliValidation extends App {
  import scalaz._
  import Scalaz._
  import scala.util.control.Exception._

  type EValidation[+T] = Validation[String, T]
  implicit val binding = new Bind[EValidation] {
    def map[A, B](fa: EValidation[A])(f: A => B): EValidation[B] = fa.map(f)
    def bind[A, B](fa: EValidation[A])(f: A => EValidation[B]): EValidation[B] = fa.flatMap(f)
  }

riipandi

#Linux Cheat Sheet

##File Commands:

• ls – directory listing
• ls -al – formatted listing with hidden files
• cd dir - change directory to dir
• cd – change to home
• pwd – show current directory
• mkdir dir – create a directory dir
• rm file – delete file

ghoseb

;;; http://srfi.schemers.org/srfi-26/srfi-26.html

(defn ^:private cut*
  [[a f] form]
  (cond
   (nil? form) [a f]

   (seq? (first form))
   (let [[arg-list xform] (cut* [[] '()] (first form))]
     (recur [(reduce conj a arg-list) (concat f (list xform))] (next form)))

sw17ch

> module Main where

First, import all the needed modules.

> import Text.Parsec hiding (State)
> import Text.Parsec.Indent
> import Control.Monad.State

Next, define our new Parser type. This replaces the Identity monad
with the (State SourcePos) monad.