https://github.com/p7g/some-functional-functions

some haskell-wannabe functions in JS (typescript)
https://github.com/p7g/some-functional-functions

functional-programming javascript typescript

Last synced: 10 days ago
JSON representation

some haskell-wannabe functions in JS (typescript)

• Host: GitHub
• URL: https://github.com/p7g/some-functional-functions
• Owner: p7g
• Created: 2018-06-30T19:20:45.000Z (over 6 years ago)
• Default Branch: master
• Last Pushed: 2018-08-26T18:05:12.000Z (over 6 years ago)
• Last Synced: 2024-10-14T11:20:56.949Z (2 months ago)
• Topics: functional-programming, javascript, typescript
• Language: TypeScript
• Homepage: https://ging0044.github.io/some-functional-functions/
• Size: 520 KB
• Stars: 0
• Watchers: 2
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# some-functional-functions

some haskell-wannabe functions in JS (typescript)

## getting started

1. import the module:

```js

import { func, pipe, compose } from "func";

// OR

const func = require("func");

```

2. use the stuff:

```js

const log = func((a, b, c) => console.log(a, b, c));

log("Wooa")("aaahh")("!");

// Wooa aaahh !

```

## the functions

See [here](https://ging0044.github.io/some-functional-functions/) for more up-to-date documentation.

### `func`

Makes a function curried. Pretty cool stuff.

It takes a function, and optionally the number of args. Use the second parameter if it's a function that takes as many args as you put.

```js

const log1 = func((a, b, c) => console.log(a, b, c));

const log2 = func(console.log, 3);

```

### `pipe`

Pipes the output of each function into the next.

The first function can take as many args as you want, but after that they should only take one. You can do some fun stuff if you use `func()` to make the functions to pass into `pipe()`, but keep in mind you'll be dealing with partially applied functions at that point.

```js

const doSomeStuff = pipe(

  x => x * 2,

  x => x ** 2,

  x => x.toString()

);

console.log(doSomeStuff(3));

// "36"

```

### `compose`

Same thing as pipe, but right to left. Like some fancy math stuff.

```js

const doSomeStuff = compose(

  x => x.toString(),

  x => x ** 2,

  x => x * 2

);

console.log(doSomeStuff(3));

// "36"

```

### `flip`

Takes a function that takes 2 arguments (or more) and flips the first 2 arguments.

```js

const flipped = flip((x, y) => `${x}, ${y}`);

console.log(flipped(1, 2));

// "2, 1"

```

### `map`

Maps an array to a function

```js

const times2 = map(x => x * 2);

console.log(times2([1, 2, 3, 4, 5]));

// [2, 4, 6, 8, 10]

```

### `foldl`

Folds (reduces) an array from the left.

```js

const sum = foldl((acc, x) => acc + x, 0);

console.log(sum([1, 2, 3]));

// 6

```

### `foldr`

Folds (reduces) an array from the right. Note that the reducer takes the item first, then the accumulator, then the index. It's like haskell!!!!!

```js

const div = foldr((x, acc) => x / acc, 1);

console.log(div([1, 2, 3, 4, 5]));

// 1.875

// this is equivalent to 1/(2/(3/(4/(5/1)))), not 1/2/3/4/5/1

```

### `reverse`

Reverses an array.

```js

console.log(reverse([1, 2, 3, 4, 5]));

// [5, 4, 3, 2, 1]

```

### `listc`

List comprehensions. Coming soon. Maybe.