Welcome to fun Discussions!

[baetheus]

Welcome to fun, the functional toolkit for Deno!

We recently hit 1.0 and since then I've quit my job to make more time for projects like this one. As of 2021/08/28 I have the following goals:

• Clear out the issue backlog
• Start chipping away at documenting every export of fun
• Implement a performant stream or observable type
• Implement a rocking parser
• Help the Deno project get their test coverage bugs sorted
• Start using fun in other projects (front end stuff, back end stuff, and in between)

If you have any features you'd like to see let me know about them! Better yet, take a crack at implementing them yourself!

Notes

Currently, I've noticed strange behavior from the deno test framework when it generates lcov data. I've wasted a few days trying to get it sorted on the consumer end but it [looks like I'm not the only one with issues]. Basically, some lines will erroneously show that they have no test coverage. This is of course an issue with generating the coverage badge and keeping all of our contributions up to snuff with test coverage. Thus, for now the test coverage is best effort and I won't be spending time worrying about keeping the lcov data itself at 100%.

[baoshan]

Is there currently a Array/sort function accepting an Ord that I can pipe data into?

I’m trying to port some code from fp-ts to fun. Hope fun is still being actively developed, really nice repo.

BTW: the coverage merge issue should be resolved.

[pixeleet]

Hey @baoshan,
It's not a built-in but porting it from fp-ts, should be fairly easy.
Would you care to open a PR?

[baetheus]

Hey @baoshan, thanks for contributing!

[baoshan]

To derive:

fabd: A -> B -> D

from:

facd: A -> C -> D
fbc: B -> C

here is my first take:

function swappedCompose<A extends unknown[], B>(
  fab: Fn<A, B>,
): <C>(fbc: Fn<[B], C>) => Fn<A, C> {
  return (fbc) => (...args) => fbc(fab(...args));
}
F.flow(facd, swappedCompose(fbc));

Basically, swappedCompose is equivalent to F.swap(F.compose) (which itself won’t compile). To avoid the home made swappedCompose, here is my second take (but the function literal looks amateur since it exactly reveals the barren vocabulary of mine):

F.flow(facd, (fcd) => F.flow(fbc, fcd));

May I be enlightened with some idiomatic FP spell? Is there a definitive name for swappedCompose? Is there some room for it in fun? Or I should find a local psychiatrist to cure my OCD? Thanks anyway.

[baetheus]

So, this is an interesting endeavor! I do not consider myself an expert on functional programming or category theory (although I endeavor to be eventually). However, this looks like one of the fundamental operations of the typed lambda calculus. It makes me think immediately of Reader and arrows.

I've been meaning to really dig into the literature on arrows, since it seems to generalize over many many patterns.

Anyway, effectively I would just type this directly to solve:

const swappedCompose = <A, C, D>(facd: (a: A) => (c: C) => D) =>
    <B>(fbc: (b: B) => C): ((a: A) => (b: B) => D) =>
        a => b => facd(a)(fbc(b));

You have it right that swap(compose) should be the correct solution. The issue is that the typescript compiler doesn't handle generics in argument positions without a lot of help. Most of the time it's easiest to implement the pattern manually, otherwise you can spend days farting around with the compiler only to have your work undone in the next minor release.

Sorry that I can't think of a nice solution here.

[baetheus]

Heya @baoshan, I'm doing some autumn cleaning of this repo and reread this question. Here are a few solutions using fun 2.0.0:

import * as F from "https://deno.land/x/[email protected]/fn.ts";

export function swappedCompose1<A, B, C, D>(
  facd: (a: A) => (c: C) => D,
  fbc: (b: B) => C,
): (a: A) => (b: B) => D {
  return F.pipe(
    facd,
    F.map(F.premap(fbc)),
  );
}

export function swappedCompose2<A, B, C, D>(
  facd: (a: A) => (c: C) => D,
  fbc: (b: B) => C,
): (a: A) => (b: B) => D {
  return F.flow(
    facd,
    F.premap(fbc),
  );
}

export function swappedCompose3<A, B, C, D>(
  facd: (a: A) => (c: C) => D,
  fbc: (b: B) => C,
): (a: A) => (b: B) => D {
  return F.pipe(
    facd,
    F.compose(F.premap(fbc)),
  );
}

export function swap<A, B, C>(
  fabc: (a: A) => (b: B) => C,
): (b: B) => (a: A) => C {
  return (b) => (a) => fabc(a)(b);
}

export function swappedCompose4<A, B, C, D>(
  facd: (a: A) => (c: C) => D,
  fbc: (b: B) => C,
): (a: A) => (b: B) => D {
  const fcad = swap(facd);
  const fbad = F.pipe(fcad, F.premap(fbc));
  const fabd = swap(fbad);
  return fabd;
}

export function swappedCompose5<A, B, C, D>(
  facd: (a: A) => (c: C) => D,
  fbc: (b: B) => C,
): (a: A) => (b: B) => D {
  return F.pipe(
    facd,
    swap,
    F.premap(fbc),
    swap,
  );
}

The core commonality between all of these is best shown in swappedCompose2. Effectively, facd returns (c: C) => D and we need to premap(or contramap) over that function to turn it into (b: B) => D. This was the missing piece in your original post. Hope this helps!