joseanpg

https://github.com/slamdata/purescript-aff/blob/master/src/Control/Monad/Aff.purs

-- | A canceler is asynchronous function that can be used to attempt the
-- | cancelation of a computation. Returns a boolean flag indicating whether
-- | or not the cancellation was successful. Many computations may be composite,
-- | in such cases the flag indicates whether any part of the computation was
-- | successfully canceled. The flag should not be used for communication.

newtype Canceler e = Canceler (Error -> Aff e Boolean)

joseanpg

http://www.w3.org/TR/2013/WD-cssom-view-20131217/

// Window Extensions

enum ScrollBehavior { "auto", "instant", "smooth" };

dictionary ScrollOptions {
  ScrollBehavior behavior = "auto";
};

joseanpg

data Maybe a = Nothing | Just a

bind :: Maybe a -> (a -> Maybe b) -> Maybe b
bind m f = case m of 
             Just x  -> f x
             Nothing -> Nothing

return :: a -> Maybe a
return x = Just x

joseanpg

import Control.Monad

transpose  [] = []
transpose  (z:zs) = foldl beta  (alpha z) zs
  where alpha = map (\x-> [x])
        beta  = zipWith (\x y-> x++[y])

transpose' [] = []
transpose' (z:zs) = map reverse $ foldl beta (alpha z) zs
  where alpha = map (\x-> [x])

joseanpg

(*

http://groups.csail.mit.edu/mac/users/adams/BB/BB.sml

    Copyright 1992-1996 Stephen Adams.

    This software may be used freely provided that:
      1. This copyright notice is attached to any copy, derived work,
         or work including all or part of this software.
      2. Any derived work must contain a prominent notice stating that

joseanpg

import Control.Monad.State

type Interact a = StateT Int IO a

repl :: Interact ()
repl = forever $ do
  val   <- liftIO readLn
  state <- get
  liftIO $ putStr "Total: "
  liftIO $ print (val + state)

joseanpg

-- Basado en
--    https://twitter.com/joseanpg/status/343757288089190401
--    https://twitter.com/joseanpg/status/343758742455738368
--    https://twitter.com/joseanpg/status/343759216424652802
--    Version ultramejorable: http://t.co/da8tx1LK6r
--    Versión Clojure by @jneira:  https://gist.github.com/jneira/5745669 
--                                 con probabilidad inversamente proporcional a las prioridades 


import Random

joseanpg

-- http://benedictgaster.org/wp-content/uploads/2012/08/haskwork97.pdf
-- Polymorphic Extensible Records for Haskell (page 3)

type Monoid v r = Rec { plus :: v -> v -> v , id :: v | r }

type Group  v r = Monoid v { inv  :: v -> v | r }

type Ring   v r = Group  v { mult :: v -> v -> v , one :: v | r }

iMonoid :: Monoid Int {}

joseanpg

var editor   = null;
var sleeping = null;
var sleepingParent = null;

function handler(ev) {
  var el   = ev.target;
  if (sleeping) {
    sleeping.innerHTML = editor.value;
    editor.value = '';
    editor.defaultValue = editor.value;

joseanpg

(function(module){

  var hop =  Object.prototype.hasOwnProperty;

  var urlEncode = function(flatObject) {
    var result = []; 
    for (var p in flatObject) if (hop.call(flatObject,p)) {
      result.push(encodeURIComponent(p)+'='+encodeURIComponent(flatObject[p]));
    }
    return result.join('&');