Frantically tried to crack this and write it up so I could squeeze this into the month just because of the alliteration and failed.

I’m not sure now how I ended up playing with Joy, but I think it was because I had Forth on my learning list and Joy was mentioned there.

It is a wee bit confusing.

You provide the arguments for a function and then the function and execute it by finishing with a period (like Erlang). So to add two numbers:

2 3 +.

Ok, so that isn’t confusing, but if you want to add the result of that sum to the result of another sum, say (2 + 3) + (4 + 5) you end up with the following:

2 3 + 4 5 + +.

It starts to get confusing. You have to mentally visualise the brackets.

There are no variables and you can’t build up intermediate results (as far as I know) to make things easier to read, you’ve got to do everything in one go. You can however use DEFINE blocks (like Erlang) to build up functions, etc up-front.

I thought I’d start with very simple programme since my poor little brain was (still is) struggling a bit to wrap itself around Joy: Given two lists of gears/sprockets (for my bike) calculate all the ratios and sort them, displaying both the ratio and the gear pairs. So if I input something like so:

DEFINE
  littlegears == [12 13 15 17 19 21 23 25];
  biggears == [34 50].

I can get an output like so:

[ [ 4.1667 "50/12"] [ 3.846 "50/13"] ... and so on ]

Calculating ratios

First step was calculating all the ratios. My first attempt was as follows:

littlegears [biggears 1 at 1.0 * /] map [-1 pow] map
littlegears [biggears 0 at 1.0 * /] map [-1 pow] map
concat.

which is tricky to understand already. The first line calculates all the ratios against the 50 and the second against 34 and both these lists are then joined together with concat. Looking at just the first line, the “50” value is obtained by biggears 1 at which leaves:

littlegears [50 1.0 * /] map [-1 pow] map

This is then multiplied by 1.0 so it’s converted to a float from an integer, which is important when it comes to dividing.

littlegears [50.0 /] map [-1 pow] map

The first map then takes the 50.0 and the divide and applies this over the littlegears list so you end up with:

[0.24 0.26 0.3 0.34 0.38 0.42 0.46 0.52] [-1 pow] map

The problem with mapping the 50 / over the list is that my divisions are inverted. I don’t want to divide the little gears by the big gears I want it the other way round. My cludgy fix for this was to raise all values to the power of minus one, effectively inverting them.

I thought there must be a better way to do this, like Haskell’s flip function. And there is:

littlegears [50.0 swap /] map.

does the same as:

littlegears [50.0 /] map [-1 pow] map

Merging Two lists as pairs

Ok, so I know how to get all the ratios, but that is not much use on it’s own. The next thing I wanted to figure out was how to merge two lists by grouping as pairs so I could have the ratios next to the gear combinations ([ [4.1667 "50/12"] ... ]). I started playing about a list containing two little lists:

[[1 2] [3 4]]

And trying to get this result:

[[1 3] [2 4]]

In Joy cons is the function use to join an element to a list so the following did the trick, but only for a two element list:

[[1 2] [3 4]] [first] map
[[1 2] [3 4]] [second] map
[] cons cons.

For a three element list I’d need:

[[1 2 3] [4 5 6]] [first] map
[[1 2 3] [4 5 6]] [second] map
[[1 2 3] [4 5 6]] [third] map
[] cons cons cons.

And so on which isn’t very sustainable for longer lists. I’m currently stuck on how to do this bit properly. I can’t find any function in the documentation that takes two lists (aggregates) so I don’t think I’m missing an easy way to do this.

Getting list of gear pairs

I couldn’t find any function to format an integer as a string. There are string to integer and string to float functions, but not the reverse as far as I can tell. So I thought I would build the results as follows: [ [ 4.1667 50 12] ... etc ] sorted on ratio.

littlegears [ [30] cons] map.

builds up the gear pairs, although the gears are listed the wrong way:

[[12 30] [13 30] [15 30] [17 30] [19 30] [21 30] [23 30] [26 30]]

If I want them the right way round it gets messier:

littlegears [ [] cons ] map [ [30] swap concat] map.

Sorting a nested list

The tutorial has an implementation of quick sort which is meant to be in the standard library - it’s not in what I’ve compiled - and I’ve tried adapting that to work on a nested list:

[[7 4] [3 5] [6 9] [1 3]]

As follows:

[small]
[]
[uncons [first >] split]
[[swap] dip cons concat]
binrec

So I get:

[[1 3] [3 5] [6 9] [7 4]]

But it doesn’t work.

And so that’s where I’m up to so far. No answers on postcards please - I’m sure I’ll figure it out sooner or later.