# mini-rosetta

These are all comparisons of J, haskell, and nial for now.

## 1 definitions

```import Data.List (sort)
import Data.Function (on)

-- reflexive transform
rfx f y = f y y

mfk f g h y = (f y) `g` (h y)
mhk = mfk id
```

### 1.2 nial

```id is pass

% reflexive transform;
rfx is tr f op y {f y y }

mhk is tr   g h op y {    y  g (h y) }
mfk is tr f g h op y { (f y) g (h y) }

square is (2 converse power)
```

## 2 running total of first 10 cardinals

```+/\ >: i.10  NB. >: is 1+, '+/' is sum, '\' is scan
```
```1 3 6 10 15 21 28 36 45 55
```
```Prelude> scanl1 (+) [0..10]
[1,3,6,10,15,21,28,36,45,55]
```
```accumulate + count 10
```
```1 3 6 10 15 21 28 36 45 55
```

## 3 addition table for the numbers `0 1 2 3`

```+/~i.4
```
```0 1 2 3
1 2 3 4
2 3 4 5
3 4 5 6
```
```Prelude> let tbl f xs=[[f x y|x<-xs]|y<-xs]
Prelude> tbl(+)[0..3]
[[0,1,2,3],[1,2,3,4],[2,3,4,5],[3,4,5,6]]
```
```rfx outer + 0 1 2 3
```
```0 1 2 3
1 2 3 4
2 3 4 5
3 4 5 6
```

## 4 repeat an operation n times

This is just doubling a number 5 times, which is the same as multiplying by 32, but it illustrates the concept:

```+~^:5 [ 1  NB. +~ (reflexive addition) is also  +: (double) in j
```
```32
```
```Prelude> let pow = (\n f -> if n == 0 then id else f . pow (n-1) f)
Prelude> pow 5 (rfx (+)) 1
32
```
```5 fold rfx + 1
```
```32
```

```(>: % +:) 2
```
```0.75
```
```Prelude> mfk (1+)(/)(2*) 2
0.75
```
```/[1 +, 2 *] 2
```
```0.75
```

## 6 check whether a series is strictly ascending

### 6.1 comparing the list to its sorted version

```(-: /:~) i.10
```
```1
```
```Prelude Data.List> mhk (==) sort [0..9]
True
```
```=[id,sortup] count 10
```
```l
```

### 6.2 comparing (all but first item) to (all but last item)

```*./ (}: < }.) i.10    NB. all (behead < curtail) i.10
```
```1
```
```Prelude> and \$ (mfk tail (zipWith (<)) init) [0..9]
True
```
```and <[front,rest] count 10
```
```l
```

Yet another way to double a number:

```(+[) 5
```
```10
```
```Prelude> mhk (+) id 5
10
```
```mhk[+,id] 5
```
```10
```

## 8 apply a function to each argument, then a second function to the results

```5 (+ & *:) 6   NB. '&' is 'atop' ... '*:' is square
```
```61
```
```Prelude Data.Function> on (+) (^2) 5 6
61
```
```% '+' is already "binary pervasive";
+ square 5 6
```
```61
```