Haskellstream

A simple library to transfer functional programming styles from Haskell into JavaScript programs. Starting with functions arounds lists and map and reduce functions which are easily partially appliable. Aim is to support functional reactive programming / streams / pipes.

Use

Install

npm install haskellstream

Examples

Curry:

var hs = require('haskellstream')
var curry = hs.core.curry

var pair = curry(function(a, b) {return [a, b]})

var pairWithTwo = pair(2)
console.log(pairWithTwo) // [Function]
console.log(pairWithTwo(3)) // [2,3]

Compose:

var hs = require('haskellstream')
var add = hs.base.add
var compose = hs.core.compose

var doubleIt = function(x) {return x + x}
var addThree = add(3)

var doubleAndAddThree = compose(addThree, doubleIt)
console.log(doubleAndAddThree(5)) // 13

Reduce:

var hs = require('haskellstream')
var add = hs.base.add
var reduce = hs.list.reduce
var range = hs.list.range

var sum = reduce(add, 0)
console.log(sum(range(1,100))) // 5050

In comparison to Haskell JavaScript is already cluttered up with lots of parenthesis commas etc. and that imported functions are usually namespaced. This noise can be reduced by assigning functions from their namespace to their plain name at the beginning of each module.

Functions covered

• core
  • curry
  • compose (b -> c) -> (a -> b) -> a -> c
  • ifThenElse :: Bool -> a -> a
  • not :: Bool -> Bool
  • flip :: (a -> b -> c) -> b -> a -> c
• base
  • succ :: Number -> Number
  • min :: Number -> Number -> Number
  • max :: Number -> Number -> Number
  • add :: Number -> Number -> Number
  • multiply :: Number -> Number -> Number
  • subtract :: Number -> Number -> Number
  • div :: Number -> Number -> Number
  • lessEqual :: Number -> Number -> Bool
  • greaterThan :: Number -> Number -> Bool
• list
  • length :: [a] -> Int
  • empty :: [a] -> Bool
  • head :: [a] -> a
  • last :: [a] -> a
  • init :: [a] -> [a]
  • tail :: [a] -> [a]
  • index :: [a] -> Int -> a
  • cons :: a -> [a] -> [a]
  • reduce :: (a -> b -> b) -> b -> [a] -> b
  • sum :: [Number] -> Number
  • product :: [Number] -> Number
  • append :: [a] -> [a] -> [a]
  • concat :: [[a]] -> [a]
  • range :: Int -> Int -> [Int]
  • filter :: [a] -> (a -> Bool) -> [a]
  • foldl :: (a -> b -> a) -> a -> [b] -> a
  • reverse :: [a] -> [a]
  • take :: Int -> [a] -> [a]
  • drop :: Int -> [a] -> [a]
  • minimum :: [Number] -> Number
  • maximum :: [Number] -> Number
• sort
  • quicksort :: [a] -> [a]

All functions that take more than one parameter can be curried (applied with too few parameter to receive a function that takes the remaining parameters).

Command Line Interface / REPL

Run ./hsci to have all functions already loaded in node's repl. It supports a command line history (via npm package repl.history).

Development

ToDo

• correct line numbers in source code reference from readme
• implement functors
• add streams

Testing

All exported functions from any module are tested.

I've looked quickly into QuickCheck. Will try to use something like that later (randomly generated values?). For now very simple tests should be sufficient.