Fantasy Land 1.0 | Hacker News Reader

Fantasy Land 1.0

github.com

103 pointsporsager33 comments

Fantasy Land is a great project—proof of how extensible JavaScript can be. There are some very interesting related projects:

https://github.com/Avaq/Fluture is basically lazy and better promises. A+ spec got nothing on this.

https://github.com/sanctuary-js/sanctuary adds better typechecks, combinators, and types like Maybe.

https://github.com/origamitower/folktale An upcoming collection of similar tools for JavaScript.

And of course, there's Ramda.

I think these libraries may sound impossible to use at work at first, but if you play with them for fun, you can at least learn some cool techniques or paradigms.

> lazy and better promises. A+ spec got nothing on this

Better how? Does it for example support unbounded recursion without stack overflow?

  function f(n) {
    if (n > 0) return Promise.resolve(n - 1).then(f)
  }

Because promises do (there is no maximum n above)

Also at a quick glance I see the following:

> Be careful when cancelling a hooked Future. If the resource was acquired but not yet consumed, it will no longer be disposed

This works in Bluebird; the resource will be disposed even if the promise is cancelled.

Promises are Eagar - it means it has the advantages of Eagerness.

Being Lazy has the advantages of laziness which is that if you do not clean your room, you became a hoarder and your room overflows.

The point I am making is that either of these tools are not holy grail. I do not think a solution for all is going to exist, just use them when it best suits the application - I think ( Like its just my dumb opinion )

also @spion I think we are going to take this argument to our death beds :D

Agreed and I probably shouldn't have said native promises are bad. I think they're okay—flutures just work better with me and how I program.

If you're interested in fantasy land, you might also be interested in:

https://github.com/rpominov/static-land

https://github.com/gcanti/flow-static-land

Javascript is in somewhat of a weird neverland currently. I really want to use this style of library -- mori, Ramda and others are extremely tempting, and fantasy-land (/static-land, which is more up my alley) are doing great work.

... but, all these libraries are huge. I feel guilty foisting hundreds of kilobytes of JS on my users, just so I can write code that I feel is slightly more elegant. I'm avidly waiting for tree-shaking/jsnext:main to truly take hold, and make these tools more practical.

Gripes aside, congratulations to the Fantasy Land team :).

Leverage Rollup's "tree-shaking" optimisation along with ES6 modules ("import { Maybe } from 'ramda-fantasy'") and you'll only be adding what features you actually use.

Combine it with a decent transpiler (I recommend Bublé) and Uglify and you're off to the races: tiny builds, that work wonderfully.

Yep! As I mentioned, I agree that this is the future :). We're just not quite there yet (mainly because lots of libraries still don't ship `jsnext:main` entries, and plenty of downstream libraries end up doing an `import _ from 'lodash'` or similar).

Totally agreed. I'm definitely looking forward to it though, that's for certain! Rollup still has a little ways to go, as does the ecosystem in general, but I'm optimistic for sure!

I know some libraries are big but this one seems pretty small? A lot of files but each one's less than 1k.

If you set up a concat+minifying step in your process (you should be doing this anyways if you're shipping a real amount of JS) then the total cost of a library like this might just be a couple kilobytes.

Angular.JS (which has a huge amount of functionality in its core) is only 50kb gzipped.

My understanding is that this is small because it's a specification :). Most of the things I've seen implement it (eg. Ramda) are larger.

Yes, I have a concat/minifying step, but as I mentioned, I'd love to see broader acceptance/implementation of tree-shaking. As it is, tying together fantasy-land, Ramda/mori, React, Redux all adds up very quickly (and that's without writing any business logic!).

You could add Google Closure Compiler to your pipeline.

The trick to not breaking your build is to know which libraries GCC can optimize without breaking.

The ones it can - browserify them seperately and then ones it cannot - browserify them later.

Its a longer step I agree, but its a small price to pay to be in Fantasy Land :D

( sorry couldn't help it )

I don't have a lot of experience with js but isn't the idea that you link to their file urls and if everyone does this than users are only downloading once and caching (typically anyway)?
Or are you more worried about page load time, not download time?

typically unless you're like me and clear cache when the browser closes...

Common misconception. Even on large web properties like Facebook, a large number of users have empty caches. For your site, with less traffic than Facebook, it'll probably be worse.

Linking to shared libraries hosted on a CDN often ends up failing because of distinct versions.

The link say absolutely nothing about what the project is.

James Forbes has an amazing article explaining Fantasy Land.

https://james-forbes.com/?/posts/the-perfect-api

I've gotta be honest, I've read about half of this so far and I'm not quite sure what I'm looking at.

Every object conforms to an interface, including some error handling functions. The interface is about composition and transformation and iteration/operation (map).

Is this about functional programming? It seems like it must, but I know very little about that and still have no real idea what the benefit of this is or even its purpose.

Edit: So I see that these are algebraic properties that are being defined, to relate it to my limited knowledge I see that Setoid define an equivalence relation interface, equals, which your objects must conform to.

My next question is what is the benefit of programming like this? Maybe I'd have to brush up on my algebra and learn how these relationships/"specifications" are useful.

I am actually kinda curious about this, but it's a little hard to penetrate.

maybe you might want to start here :- https://drboolean.gitbooks.io/mostly-adequate-guide/content/

around ch9 ( https://drboolean.gitbooks.io/mostly-adequate-guide/content/... ) they start mentioning fantasy-land and you should also have a good background in what FL is trying to achieve.

Looks interesting, thank you for the link. I've already dived in to the first chapter.

I think one benefit is facilitating "getting to grips" with new code, much like design patterns in a way. Of course, this requires familiarity. If someone tells you something is a "monoid", you instantly know that the somethings can be combined in an associative way, and that there is a "neutral" something that can always be constructed without arguments.

Another benefit is that these abstractions appear again and again under many contexts. Recognizing them allows you to give them a common interface, instead of flatMap for lists, andThen for promises, and so on.

I'm one of the unwashed masses that probably just doesn't see the Point, but I'm confused why claims like this are made.

> the last API you'll ever need

So like... if I wanted to make a post to twitter, I'm pretty sure I'd need another API.

API in this case refers to it's original meaning, that is, the interface that is available on a specific "class" of objects. Here, the "class" of objects are mimicking haskell like typeclasses.

The chart on the fantasy-land github page demonstrates the interfaces available on each typeclass. For instance, a Maybe is a functor, so it has the map interface. It's also a Monad so it has the chain interface.

Unfortunately, API is a loaded term and I think the author doesn't do a good job differentiating from the common usage of the term.

Even in that meaning, it still doesn't make sense. Say there was an abstracted twitter standard defined in an RFC, and a library was provided for interacting with it. There is no Twitter(tm), just implementations of the twitter RFC.

Even then, I need to know what the names of the properties are that I have to provide to the fantasy-land-compliant-whatever. Being an expert in fantasy land doesn't tell me that "message" is the property that contains the body of the twitter-compliant message. I still need an api.

A programatic interface can be exposed via functions over data structures, methods on objects, or HTTP requests against a server's endpoints, to name a few examples.

I think the confusion here arises from a fairly common conflation of a web service with the interface used to interact with said service.

In that case, it seems like a fairly empty claim. Here's another "last API you'll ever need".

    value["functionName"](...[arguments])

value is the the thing you're operating on. functionName is the name of the thing you want to do. arguments are any other relevant values.

The main page [1] gives some info about the project and might be a better link: "Specification for interoperability of common algebraic structures in JavaScript"

[1] https://github.com/fantasyland/fantasy-land

Now I just some way to use it with TypeScript! Unfortunately, it seems support for Higher Kindred Types is lacking. Apparently you can use some neat trick to kinda fake HKTs in Flow, but not in TypeScript, due to its lack of nominal typing. (I don't know the details, though.)

So what exactly is it? No explanation on Github. Based on the first comment here it seems to be a javascript library of some kind, but nothing on what it does or should be used for.

From the README.md on GitHub:

> (aka "Algebraic JavaScript Specification")

It's a JS library to implement algebras in code. And:

> An algebra is a set of values, a set of operators that it is closed under and some laws it must obey.

> Each Fantasy Land algebra is a separate specification. An algebra may have dependencies on other algebras which must be implemented.

So that is it. It's "weird", it has a lot of functional concepts (which may or may not be present already in the language -- I'm not a JS-guy myself). It sure must be interesting working on code that does all the things this project does, and I can see it must've required it's share of effort.

Where did you find the "README.md"? The op link has 5 bullet points from the v1.0.0 release notes and a "thanks to..."

Go to the project page[0] on GitHub and the first thing it loads is the README.md file.

[0] https://github.com/fantasyland/fantasy-land

Nice project. Of course, when I think Fantasy Land, I think of this:

https://youtube.com/watch?list=PLMs_JcuNozJa7tg80N_kITisZjHH...

There's something wrong with me.

Haskel Land is a more apt name, don't you think?

Reply on news.ycombinator.com