forked from orion/obsidian
32 lines
1.1 KiB
Markdown
32 lines
1.1 KiB
Markdown
The most common pattern by far; piping the output of a [[Functions|function]] into the input of the next.
|
|
|
|
```haskell
|
|
compose :: forall a b c. (b -> c) -> (a -> b) -> (a -> c)
|
|
compose g f a = g (f a)
|
|
```
|
|
|
|
`compose` (infix as `<<<`) accepts 2 functions; `f` which is `a -> b` and `g`; `b -> c`. `compose` returns a new function `a -> c` that "glues" the 2 functions together; piping the output of `f` into `g`.
|
|
|
|
e.g.
|
|
|
|
consider a function `normalizedPathSegments :: String -> Array String`
|
|
|
|
This function would normalize a file path, removing trailing / leading slashes and resolving relative paths, then split the path by its segments.
|
|
|
|
A very good approach would be to split this function into separate single-purpose components, e.g.
|
|
|
|
- `stripLeadingSlash :: String -> String`
|
|
- `stripTrailingSlash :: String -> String`
|
|
- `splitPath :: String -> Array String`
|
|
- `normalizePathSegments :: Array String -> Array String`
|
|
|
|
then define `normalizedPathSegments` like so:
|
|
|
|
```haskell
|
|
normalizedPathSegments :: String -> Array String
|
|
normalizedPathSegments =
|
|
normalizePathSegments
|
|
<<< splitPath
|
|
<<< stripTrailingSlash
|
|
<<< stripLeadingSlash
|
|
``` |