Added unDigits

MD applescript vs javascript/Just.md

@@ -1,18 +1,18 @@
-```javascript
-// Just :: a -> Maybe a
-const Just = x => ({
-    type: 'Maybe',
-    Nothing: false,
-    Just: x
-});
-```
-
-
 ```applescript
 -- Just :: a -> Maybe a
 on Just(x)
     -- Constructor for an inhabited Maybe (option type) value.
     -- Wrapper containing the result of a computation.
     {type:"Maybe", Nothing:false, Just:x}
 end Just
+```
+
+
+```javascript
+// Just :: a -> Maybe a
+const Just = x => ({
+    type: 'Maybe',
+    Nothing: false,
+    Just: x
+});
 ```

MD applescript vs javascript/Left.md

@@ -1,15 +1,15 @@
+```applescript
+-- Left :: a -> Either a b
+on |Left|(x)
+    {type:"Either", |Left|:x, |Right|:missing value}
+end |Left|
+```
+
+
 ```javascript
 // Left :: a -> Either a b
 const Left = x => ({
     type: 'Either',
     Left: x
 });
-```
-
-
-```applescript
--- Left :: a -> Either a b
-on |Left|(x)
-    {type:"Either", |Left|:x, |Right|:missing value}
-end |Left|
 ```

MD applescript vs javascript/Node.md

@@ -1,3 +1,11 @@
+```applescript
+-- Node :: a -> [Tree a] -> Tree a
+on Node(v, xs)
+    {type:"Node", root:v, nest:xs}
+end Node
+```
+
+
 ```javascript
 // Node :: a -> [Tree a] -> Tree a
 const Node = v =>
@@ -9,12 +17,4 @@ const Node = v =>
         root: v,
         nest: xs || []
     });
-```
-
-
-```applescript
--- Node :: a -> [Tree a] -> Tree a
-on Node(v, xs)
-    {type:"Node", root:v, nest:xs}
-end Node
 ```

MD applescript vs javascript/Nothing.md

@@ -1,17 +1,17 @@
-```javascript
-// Nothing :: Maybe a
-const Nothing = () => ({
-    type: 'Maybe',
-    Nothing: true,
-});
-```
-
-
 ```applescript
 -- Nothing :: Maybe a
 on Nothing()
     -- Constructor for an empty Maybe (option type) value.
     -- Empty wrapper returned where a computation is not possible.
     {type: "Maybe", Nothing: true}
 end Nothing
+```
+
+
+```javascript
+// Nothing :: Maybe a
+const Nothing = () => ({
+    type: 'Maybe',
+    Nothing: true,
+});
 ```

MD applescript vs javascript/Right.md

@@ -1,15 +1,15 @@
+```applescript
+-- Right :: b -> Either a b
+on |Right|(x)
+    {type:"Either", |Left|:missing value, |Right|:x}
+end |Right|
+```
+
+
 ```javascript
 // Right :: b -> Either a b
 const Right = x => ({
     type: 'Either',
     Right: x
 });
-```
-
-
-```applescript
--- Right :: b -> Either a b
-on |Right|(x)
-    {type:"Either", |Left|:missing value, |Right|:x}
-end |Right|
 ```

MD applescript vs javascript/Tuple.md

@@ -1,3 +1,12 @@
+```applescript
+-- Tuple (,) :: a -> b -> (a, b)
+on Tuple(a, b)
+    -- Constructor for a pair of values, possibly of two different types.
+    {type:"Tuple", |1|:a, |2|:b, length:2}
+end Tuple
+```
+
+
 ```javascript
 // Tuple (,) :: a -> b -> (a, b)
 const Tuple = a =>
@@ -7,13 +16,4 @@ const Tuple = a =>
         '1': b,
         length: 2
     });
-```
-
-
-```applescript
--- Tuple (,) :: a -> b -> (a, b)
-on Tuple(a, b)
-    -- Constructor for a pair of values, possibly of two different types.
-    {type:"Tuple", |1|:a, |2|:b, length:2}
-end Tuple
 ```

MD applescript vs javascript/Tuple3.md

@@ -1,3 +1,11 @@
+```applescript
+-- Tuple3 (,,) :: a -> b -> c -> (a, b, c)
+on Tuple3(x, y, z)
+    {type:"Tuple3", |1|:x, |2|:y, |3|:z, length:3}
+end Tuple3
+```
+
+
 ```javascript
 // Tuple3 (,,) :: a -> b -> c -> (a, b, c)
 const Tuple3 = a => b => c => ({
@@ -7,12 +15,4 @@ const Tuple3 = a => b => c => ({
   '2': c,
   length: 3
 });
-```
-
-
-```applescript
--- Tuple3 (,,) :: a -> b -> c -> (a, b, c)
-on Tuple3(x, y, z)
-    {type:"Tuple3", |1|:x, |2|:y, |3|:z, length:3}
-end Tuple3
 ```

MD applescript vs javascript/TupleN.md

@@ -1,3 +1,13 @@
+```applescript
+-- Requires N arguments to be wrapped as one list in AS 
+-- (the JS version accepts N separate arguments)
+-- TupleN :: a -> b ...  -> (a, b ... )
+on TupleN(argv)
+    tupleFromList(argv)
+end TupleN
+```
+
+
 ```javascript
 // TupleN :: a -> b ...  -> (a, b ... )
 function TupleN() {
@@ -13,14 +23,4 @@ function TupleN() {
         })
     ) : args.reduce((f, x) => f(x), Tuple);
 }
-```
-
-
-```applescript
--- Requires N arguments to be wrapped as one list in AS 
--- (the JS version accepts N separate arguments)
--- TupleN :: a -> b ...  -> (a, b ... )
-on TupleN(argv)
-    tupleFromList(argv)
-end TupleN
 ```

MD applescript vs javascript/abs.md

@@ -1,11 +1,3 @@
-```javascript
-// abs :: Num -> Num
-const abs = 
-// Absolute value of a given number - without the sign.
-  Math.abs;
-```
-
-
 ```applescript
 -- abs :: Num -> Num
 on abs(x)
@@ -16,4 +8,12 @@ on abs(x)
         x
     end if
 end abs
+```
+
+
+```javascript
+// abs :: Num -> Num
+const abs = 
+// Absolute value of a given number - without the sign.
+  Math.abs;
 ```

MD applescript vs javascript/add.md

@@ -1,11 +1,3 @@
-```javascript
-// add (+) :: Num a => a -> a -> a
-const add = a =>
-    // Curried addition.
-    b => a + b;
-```
-
-
 ```applescript
 -- add (+) :: Num a => a -> a -> a
 on add(a)
@@ -16,4 +8,12 @@ on add(a)
         end |λ|
     end script
 end add
+```
+
+
+```javascript
+// add (+) :: Num a => a -> a -> a
+const add = a =>
+    // Curried addition.
+    b => a + b;
 ```

MD applescript vs javascript/all.md

@@ -1,11 +1,3 @@
-```javascript
-// all :: (a -> Bool) -> [a] -> Bool
-const all = p =>
-    // True if p(x) holds for every x in xs.
-    xs => [...xs].every(p);
-```
-
-
 ```applescript
 -- all :: (a -> Bool) -> [a] -> Bool
 on all(p, xs)
@@ -18,4 +10,12 @@ on all(p, xs)
         true
     end tell
 end all
+```
+
+
+```javascript
+// all :: (a -> Bool) -> [a] -> Bool
+const all = p =>
+    // True if p(x) holds for every x in xs.
+    xs => [...xs].every(p);
 ```

MD applescript vs javascript/allSame.md

@@ -1,12 +1,3 @@
-```javascript
-// allSame :: [a] -> Bool
-const allSame = xs =>
-    2 > xs.length || (
-        h => xs.slice(1).every(x => h === x)
-    )(xs[0]);
-```
-
-
 ```applescript
 -- allSame :: [a] -> Bool
 on allSame(xs)
@@ -22,4 +13,13 @@ on allSame(xs)
         all(p, rest of xs)
     end if
 end allSame
+```
+
+
+```javascript
+// allSame :: [a] -> Bool
+const allSame = xs =>
+    2 > xs.length || (
+        h => xs.slice(1).every(x => h === x)
+    )(xs[0]);
 ```

MD applescript vs javascript/allTree.md

@@ -1,14 +1,3 @@
-```javascript
-// allTree :: (a -> Bool) -> Tree a -> Bool
-const allTree = p =>
-    // True if p holds for all nodes of the
-    // tree to which allTree(p) is applied.
-    foldTree(
-        x => xs => p(x) && xs.every(Boolean)
-    );
-```
-
-
 ```applescript
 -- allTree :: (a -> Bool) -> Tree a -> Bool
 on allTree(p, tree)
@@ -28,4 +17,15 @@ on allTree(p, tree)
     end script
     |λ|(tree) of go
 end allTree
+```
+
+
+```javascript
+// allTree :: (a -> Bool) -> Tree a -> Bool
+const allTree = p =>
+    // True if p holds for all nodes of the
+    // tree to which allTree(p) is applied.
+    foldTree(
+        x => xs => p(x) && xs.every(Boolean)
+    );
 ```

MD applescript vs javascript/and.md

@@ -1,11 +1,3 @@
-```javascript
-// and :: [Bool] -> Bool
-const and = xs =>
-    // True unless any value in xs is false.
-    [...xs].every(Boolean);
-```
-
-
 ```applescript
 -- and :: [Bool] -> Bool
 on |and|(xs)
@@ -15,4 +7,12 @@ on |and|(xs)
     end repeat
     return true
 end |and|
+```
+
+
+```javascript
+// and :: [Bool] -> Bool
+const and = xs =>
+    // True unless any value in xs is false.
+    [...xs].every(Boolean);
 ```