masaeedu/todo

things i have to do

todo

things i have to do

wat

the issues are things i need done. if you want to do them (and I can afford you), please ping <my username>@gmail.com. perhaps you also want these things done and want to pay me instead: if so, please ping <my username>@gmail.com

todo's Issues

haikubattle.com

Implement it.

`please`: fetch options from a variety of sources using JSON schema

There's lots of nonstandard ways to specify user input. It'd be nice if you could just provide a JSON schema specifying what you need from the user, and a tool would use a convention-over-configuration approach to construct a compatible object by looking in a variety of places (env vars, automatically generated command line interface, interactive prompt, config files, etc.). Should be available both as a cross platform composable CLI tool as well as a library for Node JS (at least). Be nice to have a spec so can be implemented as library in other languages.

Think about the idea of classes not only having functor instances, but applicative functor instances that can be traversed by containers

Audio forwarding to phone over LAN

I'm getting tired of forgetting to unplug myself from my laptop (or take my headphones off) before I move around. I'd rather only plug myself into my phone, which is in my pocket, then forward the laptop's audio to my phone over LAN (99% of the time both devices are on a common LAN). I usually don't care about encryption, but if you can do that and still be fast, so much the better. I don't want to sit down and configure stuff all the time, so discovery of each other's IPs is essential. It'd be nice if this was a cross platform (Windows), portable application so I can quickly install wherever I'm working and get up and running quickly.

This is probably already possible with pulseaudio or something, I just need to learn it and maybe package it up in a startup script with LAN discovery.

Add VM support to servermgr

I worked on some stuff with @maneamarius for provisioning his physical servers with operating systems, but it's just been sitting there. The next step is adding VM support. It'd be really cool to get it to a point where you can go from blank servers to openstack with a few clicks/API calls.

JS--

Like JS, but as little as possible. Hopefully little enough that a type system can be added on top.

Demonstrate that Node JS streams and Deno Readers are actually just ListT Cont!

Find more interesting functor instances for classes that allow their instances to be mapped

Some examples:

// :: type Eq a = { equals: a -> a -> Bool }

// :: Contravariant Eq
const contravariantEq = (() => {
  const contramap = ba => ({ equals }) => ({ equals: b1 => b2 => equals(ba(b1))(ba(b2)) })

  return { contramap }
})()

// :: type Semigroup s = { append: s -> s -> s }

// :: Invariant Semigroup
const invariantSemigroup = (() => {
  const invmap = nm => mn => ({ append }) => ({ append: n1 => n2 => mn(append(nm(n1))(nm(n2))) })

  return { invmap }
})()

JS userland infix operators proposal

There's a lot of proposals out there for interesting JS operators. There's much disagreement about how they should be designed, but we're all going to end up stuck with one version that satisifes someone's ideal vision of what the right way to use JS is. I think the operator design debate should happen in libraries rather than in language proposals, especially since I'm usually on the losing end of the "how it should work" discussion.

I need to find out how this proposal stuff works, study the JS grammar, and make an attempt at a proposal for first class userland infix operators. I probably need someone with more JS cred and tact to actually take this shit up, because it's not going to have a snowflake's chance in hell of getting anywhere with me proposing it directly.

HATEOAS client that consumes an API by sending emails to a person to make decisions

Rewrite rules for JS

A lot of the code in masaeedu/fp is nice to look at, but it's not very nice to run. The explosion of temporary functions isn't something the JS runtime is highly optimized for. Haskell solves this problem using rewrite rules, which lets programmers write nice, simple code, some equivalence laws that help the compiler rewrite things, and then rewrites their program by inlining stuff and substituting wherever it recognizes a construction that matches a rewrite rule.

As a concrete example, it's nice to write foo |> Arr.map(x => x + 1) |> Arr.foldl(x => y => x + y)(0), but at runtime you really want foo |> Arr.foldl(x => y => x + (y + 1))(0). There's no reason this can't be done with Babel. https://www.youtube.com/watch?v=FQRW0RM4V0k

Figure out a good way to use continuations in JS

First class continuations are an excellent way to model things like continuing a computation conditionally (as in Maybe), continuing a computation later (as in Future), continuing a computation several times (as in Array), etc. In fact continuations are so general they essentially subsume the well known do notation sugar for any and all monadic computation; given nice syntax for first class continuations, you get do notation for any monad on top for free. See http://blog.sigfpe.com/2008/12/mother-of-all-monads.html

Generators in JS almost get us there, but the problem with them is that they have an internal, ephemeral state. A generator can't be resumed multiple times from the same point with different resumption values, which limits their generality. Some libraries like pelotom/immutagen try to work around this by "emulating" immutable generators. They do this by simply replaying a generator from the beginning each time up to the point where they actually wish to resume execution of the function. This works pretty well, but is fairly inefficient.

I think the cheapest way to get in continuations in JS is to simply change how generators are implemented, so that the result of invoking a generator function is an immutable value (as seen in the immutagen API). Babel can be used to implement an alternate desugaring for function* that works in the manner described.

HM type checker for JS

Write/find/steal something that can take const foo = x => x.foo(10) and infer { "foo" :: Integer -> a } -> a, so that I can finally die happy.

wtfiid

Implement wtfiid (What The Fuck Is It Doing?), a REST API paired with a tree based user interface that indicates progress information for parallelized tasks. Any program can act as a wtfiid client and report progress information in a structured format. The wtfiid daemon can be consulted to view the progress of running tasks and diagnose hangs/slow speeds.

Add matching over multiple values to natch

We can fairly easily get nice, performant matching similar to core.match in JS, if not as ergonomically, even for multiple values. See https://www.cs.tufts.edu/~nr/cs257/archive/luc-maranget/jun08.pdf

Write a blog post about "derived" functors in JS

You can get functors for free for any datatype that consists entirely of other functors (including the identity functor for anything it is totally polymorphic with respect to). E.g. there's a functor instance for objects of arrays of functions of objects of arrays of ..., that simply dispatches to each of those functor instances as appropriate. The implementation is the same as what Haskell gives you when you do deriving Functor. This applies to things besides functors, e.g. it works for Foldable, traversable functors, and even for weird things like Either which you wouldn't commonly think of being as a "primitive" class.

Add an implementation of this stuff to masaeedu/fp and write a blog post explaining the concept.

Nix-y thing for Windows

I want Nix on Windows. There's already something pretty close with Scoop, but it doesn't do transitive hash identification of what you're installing, it's more like Arch's package management in that it'll give you the latest of everything. That's ok, but sometimes you really do want stuff to be locked down (e.g. if I want to start using this for work stuff). The template prep package management stuff I'm doing for work can probably be used for this. Be nice to be compatible with Nix, although the central format should be JSON rather than a DSL.

Addition and multiplication of church numerals

Show that multiplication of church numerals is actually a Cayley monoid for addition of church numerals, with the injective map being exponentiation.

Figure out blocking I/O for Windows process substitution

See PowerShell/PowerShell#4284

https://github.com/masaeedu/psub needs a little bit more work and investigation:

• The behavior of Powershell subshells is kind of annoying, in that if you do foo $(psub bar), the subshell needs to be completely evaluated and psub needs to exit before anything starts getting passed to foo. This sucks, because the whole output of psub needs to go into an in memory buffer, which is not how any of this is supposed to work. What we need is some ugly hax to background all of psub's logic so that it still does all that shit with waiting for someone to start eating before it starts up the child process and feeds, but the actual psub invocation exits instantly. Alternatively, kick up a stink on the powershell repo about the non streaming behavior
• It's not just PowerShell that causes problems. Lots of Windows programs will do wonky stuff like opening file handles just to peek at some metadata on the file. type, which is the closest equivalent to cat, opens the file twice, and only the second one is an attempt to actually read the file and forward it to its own stdout. My first naive attempt at just feeding the stdout to the first thing to open the pipe file failed because of this, and I had to do some bullshit with opening infinite instances of the pipe to feed anyone who cares to ask the same file (which involves reading and caching the entire stdout of the child process). Someone helped me out on Stack Overflow with this stuff, but unless I'm misinterpreting the answer, it's basically saying you're SOL, this is just how shit works on Windows. This may be a case of let sleeping dogs lie and just not use those tools with process substitution. It might be nice to have an option for selecting the behavior (replay the child process for multiple things that open the pipe, cache the output and replay that, or just go "fuck you, you're too late")

3D log view for git

Git histories with lots of merges aren't inherently bad, but they suck to look at in a 2D view. In a 3D view where branches were radially distributed about a central master branch you could offset branches from each other at an angle, and you technically have infinite space for infinitely narrow branch lines.

Finish mcneissue

Seriously, just fucking do it.

Quickcheck the Kleisli Cayley thing I was discussing with totbwf

Windows CI for open source projects

Windows often doesn't get any love in open source projects because people don't have Windows machines to test anything on interactively. See if I can set up a restricted vmctl server that is publicly available for people to reproduce issues and download/share the disk diffs.

A symptom of this is https://github.com/masaeedu/win-sshfs, which I haven't touched since I installed Arch.

Exploit isomorphisms to eliminate code in masaeedu/fp

A lot of the native types in JS are isomorphic in one way or another. A Set of [String, a]s is isomorphic to an object is isomorphic to a Map with string keys. All things that are capable of being converted to and from an iterable idempotently are isomorphic to all other such things (e.g. Cons-lists and arrays).

This means we equip a large variety of frequently encountered data with a lot of handy "methods" very cheaply, simply by implementing the relevant isomorphism. As an example, we can simultaneously equip arrays and objects with functor, foldable, traversable, etc. by first implementing these on top of the iterable protocol, and then implementing an isomorphism (or at least a split monomorphism) from each to iterables.

If this seems too handwavy and abstract, it probably is. I need to start by writing an Iterable typeclass with a to + from mdef that expects the ability to convert to and from something that satisfies the iterable protocol, move all the stuff from iter.js into methods of that typeclass, and get a bunch of shit for free on Arr by implementing to and from.