9 | 10 | 11 | 12 | ); 13 | } 14 | -------------------------------------------------------------------------------- /docs/pages/_meta.json: -------------------------------------------------------------------------------- 1 | { 2 | "index": "Introduction", 3 | "function": "Function", 4 | "option": "Option", 5 | "array": "Array", 6 | "string": "String" 7 | } 8 | -------------------------------------------------------------------------------- /docs/pages/api/hello.ts: -------------------------------------------------------------------------------- 1 | // Next.js API route support: https://nextjs.org/docs/api-routes/introduction 2 | import type { NextApiRequest, NextApiResponse } from 'next' 3 | 4 | type Data = { 5 | name: string 6 | } 7 | 8 | export default function handler( 9 | req: NextApiRequest, 10 | res: NextApiResponse 11 | ) { 12 | res.status(200).json({ name: 'John Doe' }) 13 | } 14 | -------------------------------------------------------------------------------- /docs/pages/array.mdx: -------------------------------------------------------------------------------- 1 | import { Callout } from "nextra-theme-docs"; 2 | 3 | # Array 4 | 5 | This module contains functions to work with arrays. 6 | 7 | ## Usage 8 | 9 | ### Import 10 | 11 | ```ts 12 | import * as A from "https://deno.land/x/fp_/Array.ts"; 13 | ``` 14 | 15 | ### Functions 16 | 17 | #### all 18 | 19 | `all` takes a predicate function and an array and returns true if all elements of the array satisfy the predicate. 20 | 21 | 22 | `all` works exactly like 23 | [`Array.prototype.every`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) 24 | 25 | 26 | ```ts 27 | const isEven = (n: number) => n % 2 === 0; 28 | 29 | const x = pipe([2, 4, 6], A.all(isEven)); 30 | 31 | assertEquals(x, true); 32 | ``` 33 | -------------------------------------------------------------------------------- /docs/pages/function.mdx: -------------------------------------------------------------------------------- 1 | # Function 2 | 3 | This module contains common function composition utilities. 4 | 5 | ## pipe 6 | 7 | The `pipe` function is used to chain function calls together in a more readable way. It takes a list of functions and passes the result of the first function to the second, second function to the third, and so on. The result of the last function is returned. 8 | 9 | ### Import 10 | 11 | ```ts 12 | import { pipe } from "https://deno.land/x/fp_/Function.ts"; 13 | ``` 14 | 15 | ### Usage 16 | 17 | #### Basic Example 18 | 19 | ```ts 20 | const length = (s: string): number => s.length; 21 | const double = (a: number): number => a * 2; 22 | 23 | const result = pipe( 24 | "hi", // initial value 25 | length, // "hi" is passed to `length` which returns 2 26 | double // 2 is passed to `double` which returns 4 27 | ); 28 | 29 | assertEquals(result, 4); 30 | ``` 31 | 32 | Here the `pipe` function is used to chain together the `length` and `double` functions. The `length` function is passed the initial value `"hi"` and returns `2`. The `double` function is passed `2` and returns `4`. 33 | 34 | #### Functions With Multiple Arguments (Currying) 35 | 36 | In the previous example, all of the functions just take one argument. What if we want to pass multiple arguments to a function? The `pipe` function can only pass one argument to a function, which is the output of the previous function. We can work around this by defining functions that take a single argument and return a function that takes the next argument. This is called [currying](https://en.wikipedia.org/wiki/Currying) which is a core concept in functional programming. 37 | 38 | Let's look at how we can implement a function to add two numbers together using currying. 39 | 40 | ```ts 41 | // normal function 42 | function normalAdd(a: number, b: number) { 43 | return a + b; 44 | } 45 | 46 | // curried function 47 | function curriedAdd(a: number) { 48 | return (b: number) => a + b; 49 | } 50 | ``` 51 | 52 | The `curriedAdd` function takes one argument and returns a function that takes the next argument. The returned function then adds the two arguments together and returns the result. This can be made more concise by using an arrow function. 53 | 54 | ```ts 55 | const add = (a: number) => (b: number) => a + b; 56 | ``` 57 | 58 | Now we can use the `add` function in our pipeline. 59 | 60 | ```ts 61 | const length = (s: string): number => s.length; 62 | const double = (a: number): number => a * 2; 63 | const add = (a: number) => (b: number) => a + b; 64 | 65 | const result = pipe( 66 | "hi", // initial value 67 | length, // "hi" is passed to `length` which returns 2 68 | double // 2 is passed to `double` which returns 4 69 | add(5) // 4 is passed to add which then returns a function that takes the next argument (5) and returns 9 70 | ); 71 | 72 | assertEquals(result, 9); 73 | ``` 74 | 75 | ## compose 76 | 77 | The `compose` function is similar to the `pipe` function, but instead of returning the result of the pipeline, it chains all the functions passed to it into a single function. 78 | 79 | ### Import 80 | 81 | ```ts 82 | import { compose } from "https://deno.land/x/fp_/Function.ts"; 83 | ``` 84 | 85 | ### Usage 86 | 87 | #### Basic Example 88 | 89 | ```ts 90 | const length = (s: string): number => s.length; 91 | const double = (a: number): number => a * 2; 92 | 93 | const lengthAndDouble = compose(length, double); 94 | 95 | const result = lengthAndDouble("hi"); 96 | 97 | assertEquals(result, 4); 98 | ``` 99 | 100 | Here the `compose` function is used to chain together the `length` and `double` functions. The flow of the functions is the same as the `pipe` function. The `length` function is passed the initial value `"hi"` and returns `2`. The `double` function is passed `2` and returns `4`. 101 | 102 | #### Functions With Multiple Arguments (Currying) 103 | 104 | `compose` can be used with curried functions in the same way as `pipe`. 105 | 106 | ```ts 107 | const length = (s: string): number => s.length; 108 | const double = (a: number): number => a * 2; 109 | const add = (a: number) => (b: number) => a + b; 110 | 111 | const lengthAndDoubleAndAdd = compose(length, double, add(5)); 112 | 113 | const result = lengthAndDoubleAndAdd("hi"); 114 | 115 | assertEquals(result, 9); 116 | ``` 117 | 118 | ## pipe vs compose 119 | 120 | The `pipe` and `compose` functions are almost analogous to each other. The difference is that `pipe` takes any arbitrary value as it's first argument and passes it to a chain of functions and returns the result. `compose` takes a function as it's first argument and chains it with a chain of functions and returns a new function that can be called with any arbitrary value as long it matches the type of the first function. 121 | 122 | Use `pipe` when you just want the result of a value through a chain of functions. Always default to `pipe` unless you have a specific reason to use `compose`. 123 | 124 | So what are the reasons to use `compose`? Let's say we have a function called `sumTransform` that takes a list of numbers and returns the sum of the numbers after they have been transformed by a function. 125 | 126 | ```ts 127 | const sumTransform = (numbers: number[], transform: (n: number) => number) => 128 | numbers.reduce((acc, n) => acc + transform(n), 0); 129 | ``` 130 | 131 | We can use `pipe` to pass the transform function to `sumTransform`. 132 | 133 | ```ts 134 | const sum = sumTransform([1, 2, 3], (n) => pipe(n, double, add(1))); 135 | 136 | assertEquals(sum, 15); 137 | ``` 138 | 139 | But the problem with this is that we have to pass an anonymous function to use `pipe` inside of `sumTransform`. We also need to declare an extra variable `n` to hold the current number. Every extra variable is an extra thing to keep track of and can lead to bugs. This might seem like a small thing, but it can add up quickly in a large codebase. 140 | 141 | This is where `compose` comes in. We can use `compose` to pass the transform function to `sumTransform`. 142 | 143 | ```ts 144 | const sum = sumTransform([1, 2, 3], compose(double, add(1))); 145 | 146 | assertEquals(sum, 15); 147 | ``` 148 | 149 | This is much cleaner and easier to read. 150 | 151 | ### tl;dr 152 | 153 | - Use `pipe` when you just want the result of a value through a chain of functions. 154 | - Use `compose` when you want to pass a function to another function. 155 | - Always default to `pipe` unless you have a specific reason to use `compose`. 156 | -------------------------------------------------------------------------------- /docs/pages/index.mdx: -------------------------------------------------------------------------------- 1 | # Welcome to fp_ 2 | 3 | ## Overview 4 | 5 | `fp_` is a functional programming library for Deno. It is mostly a personal project that I started because there wasn't a good functional programming library for Deno, and also I wanted to learn more about functional programming. I have ambitious goals for this project, and I hope to make it the most complete and well documented functional programming library for Deno. 6 | 7 | ## Who is this for? 8 | 9 | This is for people experienced or beginning to dabble into the world of functional programming. `fp_` will always be well documented, and I will try to make it as easy to use as possible. 10 | 11 | ## Status 12 | 13 | `fp_` is currently in development, and is not ready for production use. I will be adding more features and documentation as I go along. 14 | -------------------------------------------------------------------------------- /docs/pages/option.mdx: -------------------------------------------------------------------------------- 1 | import { Callout } from "nextra-theme-docs"; 2 | 3 | # Option 4 | 5 | This module contains an implementation of the `Option` type and it's associated functions. 6 | 7 | ## What is the Option Type? 8 | 9 | The `Option` type allows you to represent the possibility of a value being present or absent. It is a way to deal with null values in a functional way. There are two types of `Option` values: `Some` and `None`. `Some` represents a value that is present, and `None` represents a value that is absent. 10 | 11 | `Option` is the same as the enum of the same name in [Rust](https://doc.rust-lang.org/std/option/enum.Option.html) or the Maybe monad in [Haskell](https://wiki.haskell.org/Maybe) where the `Some` type is called `Just` and the `None` type is called `Nothing`. 12 | 13 | ## Why use Option? 14 | 15 | The Option type makes your code declarative and less verbose. It also makes your code more robust and less error-prone by forcing you to deal with the possibility of a value being absent. 16 | 17 | ## Usage 18 | 19 | ### Import 20 | 21 | ```ts 22 | import * as O from "https://deno.land/x/fp_/Option.ts"; 23 | ``` 24 | 25 | ### Primitives 26 | 27 | #### Some 28 | 29 | `Some` is a type that represents a value that is present. 30 | 31 | ```ts 32 | type Some = { 33 | readonly type: "some"; 34 | readonly value: T; 35 | }; 36 | ``` 37 | 38 | #### None 39 | 40 | ```ts 41 | type None = { 42 | readonly type: "none"; 43 | }; 44 | ``` 45 | 46 | #### Option 47 | 48 | `Option` is a union of the `Some` and `None` types. 49 | 50 | ```ts 51 | type Option = Some | None; 52 | ``` 53 | 54 | You won't be using these types directly for the most part, but they are useful to know about. 55 | 56 | #### some 57 | 58 | The `some` constructor can be used to create an `Option` value of type `Some`. 59 | 60 | ```ts 61 | const someValue = O.some(1); 62 | // ^? const someValue: Option 63 | ``` 64 | 65 | 66 | Only use the `some` constructor when you are sure that the value is present. 67 | 68 | 69 | #### none 70 | 71 | `none` is constant of type `Option`. 72 | 73 | ```ts 74 | const noneValue = O.none; 75 | // ^? const noneValue: Option 76 | ``` 77 | 78 | ### Creating an Option 79 | 80 | 81 | The following examples use the `pipe` function from the `Function` module. If 82 | you are not familiar with it, you can read more about it{" "} 83 | [here](/function#pipe). 84 | 85 | 86 | 87 | All the examples in this section have been kept as simple as possible so that 88 | they are easy to understand. In real-world programs you won't be writing code 89 | like this. 90 | 91 | 92 | #### fromNullable 93 | 94 | `fromNullable` creates an `Option` value and depending on the value passed in, it will either be `Some` or `None`. If the value is `null` or `undefined`, it will be `None`, otherwise it will be `Some`. 95 | 96 | ```ts 97 | const x = O.fromNullable(1); 98 | const y = O.fromNullable(null); 99 | const z = O.fromNullable(""); 100 | 101 | assertEquals(O.isSome(x), true); 102 | assertEquals(O.isNone(y), true); 103 | assertEquals(O.isSome(z), true); 104 | ``` 105 | 106 | #### fromFalsy 107 | 108 | `fromFalsy` creates an `Option` value and depending on the value passed in, it will either be `Some` or `None`. If the value is [falsy](https://developer.mozilla.org/en-US/docs/Glossary/Falsy), it will be `None`, otherwise it will be `Some`. 109 | 110 | ```ts 111 | const x = O.fromFalsy(1); 112 | const y = O.fromFalsy(null); 113 | const z = O.fromFalsy(""); 114 | 115 | assertEquals(O.isSome(x), true); 116 | assertEquals(O.isNone(y), true); 117 | assertEquals(O.isNone(z), true); 118 | ``` 119 | 120 | #### fromException 121 | 122 | `fromException` takes a function that may throw an error and returns an `Option` value. If the function throws an error, the `Option` value will be `None`, otherwise it will be `Some`. 123 | 124 | ```ts 125 | const throwIfNotOne = (x: number): number => { 126 | if (x !== 1) { 127 | throw new Error("x is not 1"); 128 | } 129 | 130 | return x; 131 | }; 132 | 133 | const x = O.fromException(() => throwIfNotOne(1)); 134 | const y = O.fromException(() => throwIfNotOne(2)); 135 | 136 | assertEquals(O.isSome(x), true); 137 | assertEquals(O.isNone(y), true); 138 | ``` 139 | 140 | 141 | `fromException` is a direct replacement for the `try`/`catch` statement. 142 | 143 | 144 | ### Checking an Option 145 | 146 | #### isOption 147 | 148 | `isOption` checks if an unknown value is an `Option`. 149 | 150 | ```ts 151 | const x = O.fromNullable(1); 152 | const y = 1; 153 | 154 | assertEquals(O.isOption(x), true); 155 | assertEquals(O.isOption(y), false); 156 | ``` 157 | 158 | #### isSome 159 | 160 | `isSome` checks if an `Option` value is of type `Some`. 161 | 162 | ```ts 163 | const x = O.fromNullable(1); 164 | const y = O.fromNullable(null); 165 | 166 | assertEquals(O.isSome(x), true); 167 | assertEquals(O.isSome(y), false); 168 | ``` 169 | 170 | #### isNone 171 | 172 | `isNone` checks if an `Option` value is of type `None`. 173 | 174 | ```ts 175 | const x = O.fromNullable(1); 176 | const y = O.fromNullable(null); 177 | 178 | assertEquals(O.isNone(x), false); 179 | assertEquals(O.isNone(y), true); 180 | ``` 181 | 182 | ### Getting the value of an Option 183 | 184 | #### unwrap 185 | 186 | `unwrap` yields the content of a `Some` value. If the value is `None`, it will throw an error. 187 | 188 | ```ts 189 | const x = pipe(O.fromNullable(1), O.unwrap()); // x = 1 190 | 191 | const y = pipe(O.none, O.unwrap()); // throws an error 192 | ``` 193 | 194 | #### expect 195 | 196 | `expect` yields the content of a `Some` value. If the value is `None`, it will throw an error with the message provided as an argument. It's the same as `unwrap` except that it allows you to provide a custom error message. 197 | 198 | ```ts 199 | const x = pipe(O.some(1), O.expect("This should not happen")); 200 | // x = 1 201 | 202 | const y = pipe(O.none, O.expect("This should happen")); 203 | // throws an error with the message "This should happen" 204 | ``` 205 | 206 | #### unwrapOr 207 | 208 | `unwrapOr` yields the content of a `Some` value. If the value is `None`, it will return the value provided as an argument. It doesn't throw an error. 209 | 210 | ```ts 211 | const x = pipe(O.fromNullable(1), O.unwrapOr(0)); // unwraps some(1) to 1 212 | const y = pipe(O.fromNullable(null), O.unwrapOr(0)); // unwraps none to default value 0 213 | 214 | assertEquals(x, 1); 215 | assertEquals(y, 0); 216 | ``` 217 | 218 | #### unwrapOrElse 219 | 220 | `unwrapOrElse` yields the content of a `Some` value. If the value is `None`, it will return the value provided as a function. It doesn't throw an error. It's similar to `unwrapOr` except that it allows you to provide a function that returns the default value so that the default value is evaluated only when needed. This is called lazy evaluation. 221 | 222 | ```ts 223 | const x = pipe( 224 | O.fromNullable(1), 225 | O.unwrapOrElse(() => 0) 226 | ); // unwraps some(1) to 1 227 | 228 | const y = pipe( 229 | O.fromNullable(null), 230 | O.unwrapOrElse(() => 0) 231 | ); // unwraps none to lazily evaluated default value 0 232 | ``` 233 | 234 | ### Operations on an Option 235 | 236 | #### map 237 | 238 | `map` is used to apply a function to the content of a `Some` value. If the value is `None` it leaves it untouched. 239 | 240 | ```ts 241 | const x = pipe( 242 | O.fromNullable(1), 243 | O.map((n) => n + 1), 244 | O.unwrapOr(0) 245 | ); 246 | 247 | const y = pipe( 248 | O.fromNullable(null), 249 | O.map((n) => n + 1), 250 | O.unwrapOr(0) 251 | ); 252 | 253 | assertEquals(x, 2); 254 | assertEquals(y, 0); 255 | ``` 256 | 257 | #### flatMap 258 | 259 | The `flatMap` function is similar to the `map` function, but it allows you to return an `Option` from the function that you pass in. It's useful when you want to compose multiple `Option` values. 260 | 261 | For example, if you have a function that returns an `Option` value and you want to call another function that also returns an `Option` value, you can use `flatMap` to compose the two functions. 262 | 263 | ```ts 264 | const withMap = pipe( 265 | O.fromNullable(1), 266 | O.map((n) => O.fromNullable(n + 1)) 267 | ); // O.Option> 268 | 269 | const withFlatMap = pipe( 270 | O.fromNullable(1), 271 | O.flatMap((n) => O.fromNullable(n + 1)) 272 | ); // O.Option 273 | ``` 274 | 275 | #### match 276 | 277 | `match` allows for pattern matching on an `Option`. It takes two functions as arguments, the first one is used if the value is `Some` and the second one is used if the value is `None`. 278 | 279 | ```ts 280 | const x = pipe( 281 | O.fromNullable(1), 282 | O.match( 283 | (n) => n + 1, 284 | () => 0 285 | ) 286 | ); 287 | 288 | const y = pipe( 289 | O.fromNullable(null), 290 | O.match( 291 | (n) => n + 1, 292 | () => 0 293 | ) 294 | ); 295 | 296 | assertEquals(x, 2); 297 | assertEquals(y, 0); 298 | ``` 299 | 300 | #### tap 301 | 302 | `tap` allows you to perform a side effect on a `Some` value. It leaves a `None` value untouched. 303 | 304 | ```ts 305 | const x = pipe( 306 | O.fromNullable(1), 307 | O.tap((n) => console.log(n)) 308 | ); // logs 1 309 | 310 | const y = pipe( 311 | O.fromNullable(null), 312 | O.tap((n) => console.log(n)), 313 | O.unwrapOr(0) 314 | ); // logs nothing 315 | ``` 316 | 317 | 318 | Side effects are generally discouraged in functional programming. Use `tap` 319 | only if it is absolutely necessary. 320 | 321 | 322 | #### zip 323 | 324 | `zip` allows you to combine two `Option` values into a tuple. If both values are `Some`, it will return a `Some` value containing a tuple of the two values. If either value is `None`, it will return `None`. 325 | 326 | ```ts 327 | const x = pipe( 328 | O.fromNullable("hello"), 329 | O.zip(O.fromNullable("world")), 330 | O.unwrapOr(["", ""]) 331 | ); 332 | 333 | const y = pipe( 334 | O.fromNullable("hello"), 335 | O.zip(O.fromNullable(null)), 336 | O.unwrapOr(["", ""]) 337 | ); 338 | 339 | assertEquals(x, ["hello", "world"]); 340 | assertEquals(y, ["", ""]); 341 | ``` 342 | -------------------------------------------------------------------------------- /docs/pages/string.mdx: -------------------------------------------------------------------------------- 1 | coming soon 2 | -------------------------------------------------------------------------------- /docs/public/favicon.ico: -------------------------------------------------------------------------------- 1 | (F (n00 (-� ��F( $]��]$ �� 8��8��#��OOO��ggg��#Y��555��Y��kkk�� Y��JJJ��kkk��Y#�� #��111�DDD��8��8 �� $]��]$( @ ,U��U,*��*��Q��Qr��rr��rO��O��(��'��888��___��SSS��+��hhh��+T��,,,��T��GGG��+++��jjj��T��III��T+��hhh��+��,,,��GGG��'��(��333�___��O��Or��rr��rQ��Q��*��*,U��U,(0` - (Lj��jK( V��U%��&��Q��R��P��O��#��#��$$$�hhh�eee�eee�eee�eee�eee�eee�eee�eee�eee�eee�eee�eee�eee�eee�eee�eee�eee�eee�eee�eee�eee�PPP��U��sss��U��eee�� HHH�� (��EEE��(K��,,,��Lj��)))��j��iii��eee��HHH��j��EEE��jL��,,,��K(��)))��( �� iii��U��eee��U��HHH��EEE��#��,,,��#��222�}}}��O��P��R��Q��&��%U��V (Kj��jL( �PNG 2 | 3 | IHDR\r�fsRGB��8eXIfMM*�i��D"8sIDATx�] �ՙn�]<QVA��h$ �N��13*�q��d�č�I��D�L2��(�(Ԙ2�ę�G ��q_@屈��xț�Џ��{o��U�{}�O��;��9�d��(Dg��8 ��N�]��@�hx�?v �N�3�=`;�6�.�&��u�� 6�P��н��@�àR�P�iZq�^DN��wp� ��X�hИHg@�� 4 | :��|�5` p"@�'�ɲ�s{ �p�*�2�� dү��|(0� 5 | 0��>K� 6 | �xX�6IJ��C|?$KEN�}ϓ|��h $ 2 ��|/�.Nz�#��W�e� 7 | �5�� ܶ��;�y�� g�s�h^I��DL(�;�8��Hjg�cH|x�1��R"�a��Ӂ�G��@��9`/`%0� H�@j�~,��K 8 | �,t).��I��D�T�O�)~��V�u$b 誛 �U%�7��_�$b 8A��J�3` 510wQ�?��vr��:�2�K�@ ��v*{%#��A�Z�咁^(��=�g\��W��!:��,`�6��643�:@�c.Fٟ��u?�<��'��_܏vp: �8Q�� 9 | I�Ł� p{3��kHȢ�G��c�Ѽ <�62&� 10 | ��2uC��敭��T�3� 11 | �� ;��d�/~m��.��X�@{�w.��d]G��{lK��Eb��(P�RuM�T�C�� d��])��_Lm�=��=@b��K��GUk�^�U��)1��g�T��m`9�\��Q��@��Ⱆ6�:ڞ�^�w��E�D�� 5��F�,�� 12 | �X"�d�m�<�nB~��@��t�t�x�� ;�f�>��I8��8��C1۪$B��e��+��jl��EZ��& ��S:�:�6�m��\G1��`��!�nl�l�Ɗ�^�Q`��@Oc�S��@e�ͷ��qb�p��S��@up��F�D@�Г��2@#��L3�A��$H2�_h��FH#rq(��O�D�򤬈��runGOWa�b�&�SgD�3�ED�to�*Ǥ��9k��~)��,$�x�R�1�v�K ��9�D䍁U(�w�&LE��ꩻ�S)��3�Y8x8$.i�(��K�ŀY��a�]��4��ǀ c��@3�f��4�Ƣ�� /*b��$!I�~��7�B*-1` o �� $��ǡD��L��J"��OQ��)��2@#�x4�"$e��I�8��Oi��8�"��G��8[x�t<�.��7&�m&؎R�^��tq�ؕ�.��Y�-2��d��*_��&d|j\�W�b ��G��*g��釁�F4�"I�؃�/b1q�N��Y�D��p��9��p�}w\��Ԥ��1 j`��O��xK=��H��A��1 �#� 13 | D:U8j��t��$b b�A||�U�Q��26%��)1 ��_ �ꢳ!~D��+b >A��:]�E$��50��GDhR�t��ݻwR�)��P��n$� 3��@bS�Nu�,Y�j�ʲ��:��;��@�`�|�-[)�'OV��Ն�sFxڮ��ۥ�n}͛7��~��ƺ�:��Q��J_��UKj8�q0x��;v4̞=[�hW=� �� &�!e5�8hѢE��w�]��6��_�iW}�SZ�? �/`�;vl�}��2<�h�"��A�܁�X,�m۶�+V�(��<�w��#F�^��;��aH�c��)S�*�{a��p��c89(�^��4�&E��oÆ ��W�/��u�=�^��*?{k^�_E��z��g��UI-��{WU* 14 | �:p�9.tڷo(/ݺus>��3�'�^�Rg��ڞG��I_D��~~��{ ��?N0�7�S��.ƍ׸�~?}/y]nA;�أ��2]�FOB2C?�_I��[�:�:�=#�OzK�-� ��ϣ�%��?j��I��P�ۯ��{N�-hU��t�:��,��G�K�-hU��c�hP7 ��@�n?�\�-�k�.��2�:�� `��F��=�-�V�_�G��܂V��}�0WI��F��ʭ��sM�rZ�8pJ�Q�*@OK8�� 15 | rZ��ݖa,��w��S�W^y��.��5�at7��ݏ��Tv#�~7n��A"��+��W��pM��/�hK8��g��F/^��M{e��R�|�)q��7�t��?8'��K��P~��瞰�\��r��>�ǷUk�eP��|�^x�� 16 | �/V/��v��*�p�v��ʟ]J��}��k8(��ĉ�ѣGǗ�O�mڴq,X�o��e.�^ �Qx��p�t��4^_�N�{��y�2�s��-عsg�s��i�v��Z 8 17 | !~PJ?�c��|�]�ܽ{��z�긓R��1pn��z��tlp�9�f�r�v�jT殿�z�4*O�L�~��ԕ3��4�~~�r�;�m�xY�+��3r�;�m�x�4��:7]ՁqL�4)U��!r�1��u�6��$� �7��8�w��̙3Ǹ|5�>?�\z��O��͆��,�E��3��2��[��2Wu:E��^p.H1cJ�t�]}��B�u��SOu��Ic�O��%� �AZ��k��D?�5�@Q�� 3�w�+��"��T��S��Uޥ�13��?��5M'݋��>p��Z�j�~fj� ׈�סԐ�n��>��i5D�[bf ��~a�'�`Xc��-�1�k��āI��k��Q�ů|�k�M��(92�@�t��݂X-�Lדa��N4��qܞ'$f0@� @V�nA�ܘY�L9:�|/^s�� )0`�j��T\w�uZ-��¨\� @�:��c�t��{�-��Rb��1%��I,Y%T��~��r�1��C��,�$��*ˀ��f<��0z��h�F��|��8Z-�CR��Tg��HRf��glY��s��-��p��'+��m�_ؒg��C�{� ��Ȫ�ϏΙ3g�-�GR|׹7`G��񥡘�0�U��_ٵZЏ�د�D�)��\>��ʗ��zN��@��~~��-��P��{rs��@�<��|.]�Ը|��m|g��_��y�W�KD1�b�M��%�s\��r�1��n�\�ƒ�"-��`.4��~%3��I}[0A��$��=-�>BH"G�ۏ�^r��<�EBG�i�%��9�@^�~~ @��1��@�t�-[��{%@C�$�mAg��Κ5kʆх��/双O��l��ӿ��B�@.X��u�p�O��6��x�9MPn�`߷o_��^n�`t� 18 | ��(��\r��s�A�y��ۂ�T��@h 19 | �E0l�0��;�tڵӘkƸN��Y�jU�� 20 | S#�|^㽺- |��p� N�.��ޥ`�^{�zL�6��4�ě�b��e�]&"�d�sΜ9Uޥ�U0�! ��*nP�*`��o֨v��i8G��hh��m��ɓ�s�=�{J�U0�Ղ��wZ��8bEz��,Y�D��![C�>}��7:k׮ �no��f�>jvR?#b��X�(��F�AT�F��i��[�{��zv��>��C��a+�[0B2�D��=��G~�( 21 | �ĺ��LO�\s�܂>"8|�`[) 22 | &Lp8�'��4oGe�#�ۏ�lْ_\�D̀܂�2Z�l��i�9�� t�ȑ9f ޢ�-��=��Y�y��n?uQ�}Xͬ�sA�i>=��1�=R��+� + �܂��.2��K��CƢۃ20h� �˫%53�5@�MA�%��̣��j[��9�;��_(��0��~r��\�{�m�P��x#TT9��n?��N#��ץ&�}��) 23 | �T�VL�!��j��`�p �8@Rr�UAV�A��=��-��pLH�`@n�*Ȋ1�܂U��?}w ]�H2@�ߴi��V��[�˯%��5�8�)Э 24 | T`��|rZbZ-�.�!da+@��ߞ�Z�gf�[0p�� I��gr�$��o%P�_rCy �V�|߽��"m�Y��-�[l��kxA��ۯ9]�[pҤI�Ȩ�pP��k��Feِ��gHE�d�nAm"Z�$��5}��z�8��2r�X�|� ��Sܻw��r�J�s�J�~�T�f�z{�ͫ��x�j?j��Q�E�n��js��|G�xз��󕾤�rzr�� `��V{��u��4448�V��ra��p��QRZ�<{�dK.F9��#~T��s.��N%*� ��Ýu�8G&��/W:*x%�{�}@� ��l��Nc#�AI��i��*?�د�0}�g��C"Āpۯ��4薒ҏ(b�8�_Q�Y� ��r7'��`�� j�6�� *��3�W�g��"��l� �1�:�Sg}%� � ��P?��1`��Y��"��D�0b@��9��[t��F1��p`k�\U�`��R��A#W81 e`)R�ZM��[u��F0� rq.��#^�=C"Ā9P'�R~f�� 27 | pn�zdC"�e��?�\K��@&$b }jz�3۵�x/{��1 Ra�#�|��ƟUK�=&�^��TM�n�2�9�5)?s��{O'�D��D��o[kM�oK0�x��Td�_@]b r� �G��;��D��D��1�gaR�`��'`0� �>\��/��f��ŀ��!fn�Z�|b��U�.t��ट��r�9�+�� b rnE�Dk�=��8��!b R�Cl�P�E�`�܌�K�'~�@��}*�!`�@��6L� �;�� $b@D��?#��g�F� 28 | ��V��1�v��;�Es��Q��=ɮ�4��b@T��n��!��3q�0^�V��c��1�ܶ��[��M�=8I��1@�څ@Cu��`N�o��WJĀ�W��e��I��n��N�mீ��ܴ�_d��(�4`E܅I��"̵�1 *3�+\�E� �\M��)g r�� 29 | ��8�>��p�?vI��0�ǀ~�!b��$'�%"I��R��i�1 �0��?S~&��r��{ n�_��L�?��T�e��Ǝ�7�C"r��OQ~"qI��O8�?$b �܋r�#@�_�v�J̙��/��3�'d�/��W[��o'N� �l��-2��@j�O~��0��2`H�@�؄��+��pOB��uO��(l�S�ԕ��9��~�c�:x/�Xd�.��Ɣ�d��V�y@F$H2��+M*�i��l8O@F$H2��2�4&r� PO��֢��7N�YS ��Y�1`��;�JS3n� g[�'��@W@"la`32�n?'�HB2p 30 | �hām�mu ��j@F@��V��Z!��xI��H�y�ѱ)��>��Z!6��a�`��dDV$9f�� pM�6�I�!LG:\LdrwPy�~�P�%��L3��7�TK��Am�mo|�6�� 3��-�hJ3��?�67 �yr��"��g��4.$�1��_�[*��&��S/�dq��C��h�3��>�6Ŷ%��\�#�RZq� �=lK|ŔX��X�WS�ej5/��$��:��v@��8�� d��1(�z2~F�)��3��͋��l��C��#��=�.\Lt? %�N$9b�%�:��2��u �1|-� ld��t$b��@?��@� �F�c��ρ^�D�d�[9�ࠐz��: 31 | H�@ ��P2v)~��@��z5��|��R�ֵ��|`#�W39؂��<�"-�0��\<�d��u�oGLz1��Gp��e�倯d�.�j H�@j�F�3��@ c{s<��J& �@��b��w�� n��v��< ��,M;��*p>p!0hH��{=��x�]I��DLh��<'��h8�@V �#��J��f�I��Hn��W�}�N�t[u�$�� @� 2 �]&)��#�3��, =%�T��k�&� I��I��ӳ��[8 � �L�]�]t�T�g��6�-@b2U�OV��: A?�� }.i�| �xC��rv�w;��#�>�i8_b82�WP��{'n��8�z;�Ƥy��s��@��P��o|�S�ih$3��@߹j��IEND�B`� -------------------------------------------------------------------------------- /docs/public/next.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /docs/public/thirteen.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /docs/public/vercel.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /docs/theme.config.jsx: -------------------------------------------------------------------------------- 1 | import React from "react"; 2 | import { useRouter } from "next/router"; 3 | 4 | // eslint-disable-next-line import/no-anonymous-default-export 5 | export default { 6 | useNextSeoProps() { 7 | const { asPath } = useRouter(); 8 | if (asPath !== "/") { 9 | return { 10 | titleTemplate: "%s • fp_", 11 | }; 12 | } else { 13 | return { 14 | title: "fp_", 15 | }; 16 | } 17 | }, 18 | logo: fp_, 19 | docsRepositoryBase: "https://github.com/nexxeln/fp/docs/pages", 20 | feedback: { 21 | content: null, 22 | }, 23 | project: { 24 | link: "https://github.com/nexxeln/fp", 25 | }, 26 | // ... 27 | }; 28 | -------------------------------------------------------------------------------- /docs/tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | "target": "es5", 4 | "lib": ["dom", "dom.iterable", "esnext"], 5 | "allowJs": true, 6 | "skipLibCheck": true, 7 | "strict": true, 8 | "forceConsistentCasingInFileNames": true, 9 | "noEmit": true, 10 | "esModuleInterop": true, 11 | "module": "esnext", 12 | "moduleResolution": "node", 13 | "resolveJsonModule": true, 14 | "isolatedModules": true, 15 | "jsx": "preserve", 16 | "incremental": true, 17 | "baseUrl": ".", 18 | "paths": { 19 | "~/*": ["./*"] 20 | } 21 | }, 22 | "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"], 23 | "exclude": ["node_modules"] 24 | } 25 | -------------------------------------------------------------------------------- /functions/compose.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * Composes functions into one function from left to right. 3 | * 4 | * @example 5 | * ``` 6 | * type Person = { name: string; age: number }; 7 | * 8 | * const fn = compose( 9 | * (p: Person) => ({ ...p, age: p.age + 1 }), 10 | * (p) => ({ ...p, name: p.name.toUpperCase() }) 11 | * ); 12 | * 13 | * 14 | * const result = fn({ name: "John", age: 20 }); 15 | * 16 | * assertEquals(result, { name: "JOHN", age: 21 }); 17 | * ``` 18 | */ 19 | export function compose, B>( 20 | fn1: (...a: A) => B 21 | ): (...a: A) => B; 22 | export function compose , B, C>( 23 | fn1: (...a: A) => B, 24 | fn2: (b: B) => C 25 | ): (...a: A) => C; 26 | export function compose , B, C, D>( 27 | fn1: (...a: A) => B, 28 | fn2: (b: B) => C, 29 | fn3: (c: C) => D 30 | ): (...a: A) => D; 31 | export function compose , B, C, D, E>( 32 | fn1: (...a: A) => B, 33 | fn2: (b: B) => C, 34 | fn3: (c: C) => D, 35 | fn4: (d: D) => E 36 | ): (...a: A) => E; 37 | export function compose , B, C, D, E, F>( 38 | fn1: (...a: A) => B, 39 | fn2: (b: B) => C, 40 | fn3: (c: C) => D, 41 | fn4: (d: D) => E, 42 | fn5: (e: E) => F 43 | ): (...a: A) => F; 44 | export function compose , B, C, D, E, F, G>( 45 | fn1: (...a: A) => B, 46 | fn2: (b: B) => C, 47 | fn3: (c: C) => D, 48 | fn4: (d: D) => E, 49 | fn5: (e: E) => F, 50 | fn6: (f: F) => G 51 | ): (...a: A) => G; 52 | export function compose , B, C, D, E, F, G, H>( 53 | fn1: (...a: A) => B, 54 | fn2: (b: B) => C, 55 | fn3: (c: C) => D, 56 | fn4: (d: D) => E, 57 | fn5: (e: E) => F, 58 | fn6: (f: F) => G, 59 | fn7: (g: G) => H 60 | ): (...a: A) => H; 61 | export function compose< 62 | A extends ReadonlyArray, 63 | B, 64 | C, 65 | D, 66 | E, 67 | F, 68 | G, 69 | H, 70 | I 71 | >( 72 | fn1: (...a: A) => B, 73 | fn2: (b: B) => C, 74 | fn3: (c: C) => D, 75 | fn4: (d: D) => E, 76 | fn5: (e: E) => F, 77 | fn6: (f: F) => G, 78 | fn7: (g: G) => H, 79 | fn8: (h: H) => I 80 | ): (...a: A) => I; 81 | export function compose< 82 | A extends ReadonlyArray, 83 | B, 84 | C, 85 | D, 86 | E, 87 | F, 88 | G, 89 | H, 90 | I, 91 | J 92 | >( 93 | fn1: (...a: A) => B, 94 | fn2: (b: B) => C, 95 | fn3: (c: C) => D, 96 | fn5: (e: E) => F, 97 | fn6: (f: F) => G, 98 | fn7: (g: G) => H, 99 | fn8: (h: H) => I, 100 | fn9: (i: I) => J 101 | ): (...a: A) => J; 102 | export function compose< 103 | A extends ReadonlyArray, 104 | B, 105 | C, 106 | D, 107 | E, 108 | F, 109 | G, 110 | H, 111 | I, 112 | J, 113 | K 114 | >( 115 | fn1: (...a: A) => B, 116 | fn2: (b: B) => C, 117 | fn3: (c: C) => D, 118 | fn5: (e: E) => F, 119 | fn6: (f: F) => G, 120 | fn7: (g: G) => H, 121 | fn8: (h: H) => I, 122 | fn9: (i: I) => J, 123 | fn10: (j: J) => K 124 | ): (...a: A) => K; 125 | export function compose< 126 | A extends ReadonlyArray, 127 | B, 128 | C, 129 | D, 130 | E, 131 | F, 132 | G, 133 | H, 134 | I, 135 | J, 136 | K, 137 | L 138 | >( 139 | fn1: (...a: A) => B, 140 | fn2: (b: B) => C, 141 | fn3: (c: C) => D, 142 | fn5: (e: E) => F, 143 | fn6: (f: F) => G, 144 | fn7: (g: G) => H, 145 | fn8: (h: H) => I, 146 | fn9: (i: I) => J, 147 | fn10: (j: J) => K, 148 | fn11: (k: K) => L 149 | ): (...a: A) => L; 150 | export function compose< 151 | A extends ReadonlyArray, 152 | B, 153 | C, 154 | D, 155 | E, 156 | F, 157 | G, 158 | H, 159 | I, 160 | J, 161 | K, 162 | L, 163 | M 164 | >( 165 | fn1: (...a: A) => B, 166 | fn2: (b: B) => C, 167 | fn3: (c: C) => D, 168 | fn5: (e: E) => F, 169 | fn6: (f: F) => G, 170 | fn7: (g: G) => H, 171 | fn8: (h: H) => I, 172 | fn9: (i: I) => J, 173 | fn10: (j: J) => K, 174 | fn11: (k: K) => L, 175 | fn12: (k: L) => M 176 | ): (...a: A) => M; 177 | // deno-lint-ignore ban-types 178 | export function compose(fn1: Function, ...fns: Function[]) { 179 | if (fns.length === 0) { 180 | return fn1; 181 | } 182 | 183 | return (...args: unknown[]) => 184 | fns.reduce((prev, fn) => fn(prev), fn1(...args)); 185 | } 186 | -------------------------------------------------------------------------------- /functions/compose_test.ts: -------------------------------------------------------------------------------- 1 | import { assertEquals } from "https://deno.land/std@0.177.0/testing/asserts.ts"; 2 | 3 | import { compose } from "./compose.ts"; 4 | 5 | Deno.test("compose - single function", () => { 6 | const addOne = (n: number) => n + 1; 7 | 8 | const fn = compose(addOne); 9 | 10 | const result = fn(0); 11 | 12 | assertEquals(result, 1); 13 | }); 14 | 15 | Deno.test("compose - multiple functions", () => { 16 | const addOne = (n: number) => n + 1; 17 | const addTwo = (n: number) => n + 2; 18 | const timesTen = (n: number) => n * 10; 19 | 20 | const fn = compose(addOne, addTwo, timesTen); 21 | 22 | const result = fn(1); 23 | 24 | assertEquals(result, 40); 25 | }); 26 | 27 | Deno.test("compose - string manipulation", () => { 28 | const toUpperCase = (str: string) => str.toUpperCase(); 29 | const addExclamation = (str: string) => `${str}!`; 30 | 31 | const fn = compose(toUpperCase, addExclamation); 32 | 33 | const result = fn("hello"); 34 | 35 | assertEquals(result, "HELLO!"); 36 | }); 37 | 38 | Deno.test("compose - array manipulation", () => { 39 | const fn = compose( 40 | (arr: string[]) => arr.map((char) => char.toUpperCase()), 41 | (arr) => arr.map((char) => `${char}!`), 42 | (arr) => arr.join("") 43 | ); 44 | 45 | const result = fn(["h", "e", "l", "l", "o"]); 46 | 47 | assertEquals(result, "H!E!L!L!O!"); 48 | }); 49 | 50 | Deno.test("compose - object manipulation", () => { 51 | type Person = { name: string; age: number }; 52 | 53 | const fn = compose( 54 | (p: Person) => ({ ...p, age: p.age + 1 }), 55 | (p) => ({ ...p, name: p.name.toUpperCase() }) 56 | ); 57 | 58 | const result = fn({ name: "John", age: 20 }); 59 | 60 | assertEquals(result, { name: "JOHN", age: 21 }); 61 | }); 62 | -------------------------------------------------------------------------------- /functions/pipe.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * Pipes the value of an expression into a pipeline of functions. 3 | * 4 | * @example 5 | * ``` 6 | * type Person = { name: string; age: number }; 7 | * 8 | * const result = pipe( 9 | * { name: "John", age: 20} 10 | * (p: Person) => ({ ...p, age: p.age + 1 }), 11 | * (p) => ({ ...p, name: p.name.toUpperCase() }) 12 | * ); 13 | * 14 | * assertEquals(result, { name: "JOHN", age: 21 }); 15 | * ``` 16 | */ 17 | export function pipe (value: A): A; 18 | export function pipe(value: A, fn1: (input: A) => B): B; 19 | export function pipe( 20 | value: A, 21 | fn1: (input: A) => B, 22 | fn2: (input: B) => C 23 | ): C; 24 | export function pipe( 25 | value: A, 26 | fn1: (input: A) => B, 27 | fn2: (input: B) => C, 28 | fn3: (input: C) => D 29 | ): D; 30 | export function pipe( 31 | value: A, 32 | fn1: (input: A) => B, 33 | fn2: (input: B) => C, 34 | fn3: (input: C) => D, 35 | fn4: (input: D) => E 36 | ): E; 37 | export function pipe( 38 | value: A, 39 | fn1: (input: A) => B, 40 | fn2: (input: B) => C, 41 | fn3: (input: C) => D, 42 | fn4: (input: D) => E, 43 | fn5: (input: E) => F 44 | ): F; 45 | export function pipe( 46 | value: A, 47 | fn1: (input: A) => B, 48 | fn2: (input: B) => C, 49 | fn3: (input: C) => D, 50 | fn4: (input: D) => E, 51 | fn5: (input: E) => F, 52 | fn6: (input: F) => G 53 | ): G; 54 | export function pipe( 55 | value: A, 56 | fn1: (input: A) => B, 57 | fn2: (input: B) => C, 58 | fn3: (input: C) => D, 59 | fn4: (input: D) => E, 60 | fn5: (input: E) => F, 61 | fn6: (input: F) => G, 62 | fn7: (input: G) => H 63 | ): H; 64 | export function pipe( 65 | value: A, 66 | fn1: (input: A) => B, 67 | fn2: (input: B) => C, 68 | fn3: (input: C) => D, 69 | fn4: (input: D) => E, 70 | fn5: (input: E) => F, 71 | fn6: (input: F) => G, 72 | fn7: (input: G) => H, 73 | fn8: (input: H) => I 74 | ): I; 75 | export function pipe( 76 | value: A, 77 | fn1: (input: A) => B, 78 | fn2: (input: B) => C, 79 | fn3: (input: C) => D, 80 | fn4: (input: D) => E, 81 | fn5: (input: E) => F, 82 | fn6: (input: F) => G, 83 | fn7: (input: G) => H, 84 | fn8: (input: H) => I, 85 | fn9: (input: I) => J 86 | ): J; 87 | export function pipe( 88 | value: A, 89 | fn1: (input: A) => B, 90 | fn2: (input: B) => C, 91 | fn3: (input: C) => D, 92 | fn4: (input: D) => E, 93 | fn5: (input: E) => F, 94 | fn6: (input: F) => G, 95 | fn7: (input: G) => H, 96 | fn8: (input: H) => I, 97 | fn9: (input: I) => J, 98 | fn10: (input: J) => K 99 | ): K; 100 | export function pipe( 101 | value: A, 102 | fn1: (input: A) => B, 103 | fn2: (input: B) => C, 104 | fn3: (input: C) => D, 105 | fn4: (input: D) => E, 106 | fn5: (input: E) => F, 107 | fn6: (input: F) => G, 108 | fn7: (input: G) => H, 109 | fn8: (input: H) => I, 110 | fn9: (input: I) => J, 111 | fn10: (input: J) => K, 112 | fn11: (input: K) => L 113 | ): L; 114 | export function pipe( 115 | value: A, 116 | fn1: (input: A) => B, 117 | fn2: (input: B) => C, 118 | fn3: (input: C) => D, 119 | fn4: (input: D) => E, 120 | fn5: (input: E) => F, 121 | fn6: (input: F) => G, 122 | fn7: (input: G) => H, 123 | fn8: (input: H) => I, 124 | fn9: (input: I) => J, 125 | fn10: (input: J) => K, 126 | fn11: (input: K) => L, 127 | fn12: (input: L) => M 128 | ): M; 129 | 130 | // deno-lint-ignore ban-types 131 | export function pipe(value: unknown, ...fns: Function[]): unknown { 132 | return fns.reduce((acc, fn) => fn(acc), value); 133 | } 134 | -------------------------------------------------------------------------------- /functions/pipe_test.ts: -------------------------------------------------------------------------------- 1 | import { assertEquals } from "https://deno.land/std@0.177.0/testing/asserts.ts"; 2 | 3 | import { pipe } from "./pipe.ts"; 4 | 5 | // chatgpt wrote these tests because i cba to write them myself 6 | 7 | Deno.test("pipe - single function", () => { 8 | const addOne = (num: number) => num + 1; 9 | 10 | const result = pipe(0, addOne); 11 | 12 | assertEquals(result, 1); 13 | }); 14 | 15 | Deno.test("pipe - multiple functions", () => { 16 | const addOne = (num: number) => num + 1; 17 | const double = (num: number) => num * 2; 18 | 19 | const result = pipe(0, addOne, double); 20 | 21 | assertEquals(result, 2); 22 | }); 23 | 24 | Deno.test("pipe - string manipulation", () => { 25 | const toUpperCase = (str: string) => str.toUpperCase(); 26 | const addExclamation = (str: string) => `${str}!`; 27 | 28 | const result = pipe("hello", toUpperCase, addExclamation); 29 | 30 | assertEquals(result, "HELLO!"); 31 | }); 32 | 33 | Deno.test("pipe - array manipulation", () => { 34 | const addOne = (num: number) => num + 1; 35 | const double = (num: number) => num * 2; 36 | 37 | const result = pipe( 38 | [0, 1, 2], 39 | (x) => x.map((i) => addOne(i)), 40 | (x) => x.map((i) => double(i)) 41 | ); 42 | 43 | assertEquals(result, [2, 4, 6]); 44 | }); 45 | 46 | Deno.test("pipe - object manipulation", () => { 47 | type Person = { name: string; age: number }; 48 | 49 | const result = pipe( 50 | { name: "John", age: 20 }, 51 | (p: Person) => ({ ...p, age: p.age + 1 }), 52 | (p) => ({ ...p, name: p.name.toUpperCase() }) 53 | ); 54 | 55 | assertEquals(result, { name: "JOHN", age: 21 }); 56 | }); 57 | 58 | Deno.test("pipe - empty function list", () => { 59 | const result = pipe("hello"); 60 | 61 | assertEquals(result, "hello"); 62 | }); 63 | --------------------------------------------------------------------------------