sjoerdvisscher

{-# LANGUAGE RankNTypes, TypeOperators, KindSignatures, ScopedTypeVariables #-}

import Control.Functor.HigherOrder 
import Control.Functor.Extras

newtype K k    (r :: * -> *) a = K k
newtype I f    (r :: * -> *) a = I (r (f a))
newtype E      (r :: * -> *) a = E a
data (f :*: g) (r :: * -> *) a = f r a :*: g r a
data (f :+: g) (r :: * -> *) a = L (f r a) | R (g r a)

jagbolanos

--Proposed solutions to problems 87,88 and 89 of "99 Haskell Problems"
--Not optimal but they work
--If you know haskell and want to solve some problems there are some missing at:
--http://www.haskell.org/haskellwiki/99_questions/80_to_89

import Data.List

type Node = Int
type Edge = (Node,Node)
type Graph = ([Node],[Edge])

sjoerdvisscher

{-# LANGUAGE TypeFamilies, DeriveFunctor #-}

import Data.Key (Key)
import Data.Functor.Foldable (Fix(..), fold, unfold)

import Control.Applicative
import Control.Arrow (left)


data RF f a r = RF { getRF :: Key f -> Either a (Key f, r) } deriving Functor

Kedrigern

{- Implementation of BST (binary search tree)
Script is absolutly free/libre, but with no guarantee.
Author: Ondrej Profant -}

import qualified Data.List

{- DEF data structure -}
data (Ord a, Eq a) => Tree a = Nil | Node (Tree a) a (Tree a) 
	deriving Show

orclev

import Data.Maybe
import Control.Monad (liftM)
import Data.List (isPrefixOf)
import qualified Data.Map as M
import qualified Data.Foldable as F

-- | Trie container data type
data Trie a = Trie { value    :: Maybe a
                   , children :: M.Map Char (Trie a) }
              deriving (Show)

folone

$ ghci
GHCi, version 7.4.2: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude> :l hello-ski.hs 
[1 of 1] Compiling Main             ( hello-ski.hs, interpreted )
Ok, modules loaded: Main.
*Main> main
Hello world!

hallettj

/*
 * Example of a state monad in use.  This is adapted from an example on
 * the Haskell Wiki:
 * http://www.haskell.org/haskellwiki/State_Monad#Complete_and_Concrete_Example_1
 */
require(['state', 'qunit'], function(state, qunit) {

    /*
     * playGame() is a recursive function that given an array of moves
     * defines an algorithm for constructing a final game score.  Along

asalant

var mongoose = require('mongoose')
var mongoUrl = "mongodb://localhost:27017/test"

var connectWithRetry = function() {
  return mongoose.connect(mongoUrl, function(err) {
    if (err) {
      console.error('Failed to connect to mongo on startup - retrying in 5 sec', err);
      setTimeout(connectWithRetry, 5000);
    }
  });

akihiro4chawon

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TupleSections     #-}

module Main where

import           Control.Applicative
import           Control.Arrow
import           Control.Monad                    (void)
import           Data.Attoparsec.ByteString.Char8
import qualified Data.ByteString.Char8            as B

theangryangel

// api/controllers/AuthController.js

var passport = require('passport');

var AuthController = {

  login: function (req,res)
	{
		res.view();
	},