2016 Update

Task/Flatten-a-list/00DESCRIPTION

@@ -1,6 +1,13 @@
-Write a function to flatten the nesting in an arbitrary [[wp:List (computing)|list]] of values. Your program should work on the equivalent of this list:
-   [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]
+;Task:
+Write a function to flatten the nesting in an arbitrary   [[wp:List (computing)|list]] of values.
+
+
+Your program should work on the equivalent of this list:
+   [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]
 Where the correct result would be the list:
     [1, 2, 3, 4, 5, 6, 7, 8]
 
-C.f. [[Tree traversal]]
+
+;Related task:
+*   [[Tree traversal]]
+<br><br>

Task/Flatten-a-list/Ada/flatten-a-list-1.ada

@@ -0,0 +1,32 @@
+generic
+   type Element_Type is private;
+   with function To_String (E : Element_Type) return String is <>;
+package Nestable_Lists is
+
+   type Node_Kind is (Data_Node, List_Node);
+
+   type Node (Kind : Node_Kind);
+
+   type List is access Node;
+
+   type Node (Kind : Node_Kind) is record
+      Next : List;
+      case Kind is
+         when Data_Node =>
+            Data    : Element_Type;
+         when List_Node =>
+            Sublist : List;
+      end case;
+   end record;
+
+   procedure Append (L : in out List; E : Element_Type);
+   procedure Append (L : in out List; N : List);
+
+   function Flatten (L : List) return List;
+
+   function New_List (E : Element_Type) return List;
+   function New_List (N : List) return List;
+
+   function To_String (L : List) return String;
+
+end Nestable_Lists;

Task/Flatten-a-list/Ada/flatten-a-list-2.ada

@@ -0,0 +1,79 @@
+with Ada.Strings.Unbounded;
+
+package body Nestable_Lists is
+
+   procedure Append (L : in out List; E : Element_Type) is
+   begin
+      if L = null then
+         L := new Node (Kind => Data_Node);
+         L.Data := E;
+      else
+         Append (L.Next, E);
+      end if;
+   end Append;
+
+   procedure Append (L : in out List; N : List) is
+   begin
+      if L = null then
+         L := new Node (Kind => List_Node);
+         L.Sublist := N;
+      else
+         Append (L.Next, N);
+      end if;
+   end Append;
+
+   function Flatten (L : List) return List is
+      Result  : List;
+      Current : List := L;
+      Temp    : List;
+   begin
+      while Current /= null loop
+         case Current.Kind is
+            when Data_Node =>
+               Append (Result, Current.Data);
+            when List_Node =>
+               Temp := Flatten (Current.Sublist);
+               while Temp /= null loop
+                  Append (Result, Temp.Data);
+                  Temp := Temp.Next;
+               end loop;
+         end case;
+         Current := Current.Next;
+      end loop;
+      return Result;
+   end Flatten;
+
+   function New_List (E : Element_Type) return List is
+   begin
+      return  new Node'(Kind => Data_Node, Data => E, Next => null);
+   end New_List;
+
+   function New_List (N : List) return List is
+   begin
+      return new Node'(Kind => List_Node, Sublist => N, Next => null);
+   end New_List;
+
+   function To_String (L : List) return String is
+      Current : List := L;
+      Result  : Ada.Strings.Unbounded.Unbounded_String;
+   begin
+      Ada.Strings.Unbounded.Append (Result, "[");
+      while Current /= null loop
+         case Current.Kind is
+            when Data_Node =>
+               Ada.Strings.Unbounded.Append
+                 (Result, To_String (Current.Data));
+            when List_Node =>
+               Ada.Strings.Unbounded.Append
+                 (Result, To_String (Current.Sublist));
+         end case;
+         if Current.Next /= null then
+            Ada.Strings.Unbounded.Append (Result, ", ");
+         end if;
+         Current := Current.Next;
+      end loop;
+      Ada.Strings.Unbounded.Append (Result, "]");
+      return Ada.Strings.Unbounded.To_String (Result);
+   end To_String;
+
+end Nestable_Lists;

Task/Flatten-a-list/Ada/flatten-a-list-3.ada

@@ -0,0 +1,29 @@
+with Ada.Text_IO;
+with Nestable_Lists;
+
+procedure Flatten_A_List is
+   package Int_List is new Nestable_Lists
+     (Element_Type => Integer,
+      To_String    => Integer'Image);
+
+   List : Int_List.List := null;
+begin
+   Int_List.Append (List, Int_List.New_List (1));
+   Int_List.Append (List, 2);
+   Int_List.Append (List, Int_List.New_List (Int_List.New_List (3)));
+   Int_List.Append (List.Next.Next.Sublist.Sublist, 4);
+   Int_List.Append (List.Next.Next.Sublist, 5);
+   Int_List.Append (List, Int_List.New_List (Int_List.New_List (null)));
+   Int_List.Append (List, Int_List.New_List (Int_List.New_List
+                    (Int_List.New_List (6))));
+   Int_List.Append (List, 7);
+   Int_List.Append (List, 8);
+   Int_List.Append (List, null);
+
+   declare
+      Flattened : constant Int_List.List := Int_List.Flatten (List);
+   begin
+      Ada.Text_IO.Put_Line (Int_List.To_String (List));
+      Ada.Text_IO.Put_Line (Int_List.To_String (Flattened));
+   end;
+end Flatten_A_List;

Task/Flatten-a-list/AppleScript/flatten-a-list-1.applescript

@@ -0,0 +1,11 @@
+my_flatten({{1}, 2, {{3, 4}, 5}, {{{}}}, {{{6}}}, 7, 8, {}})
+
+on my_flatten(aList)
+    if class of aList is not list then
+        return {aList}
+    else if length of aList is 0 then
+        return aList
+    else
+        return my_flatten(first item of aList) & (my_flatten(rest of aList))
+    end if
+end my_flatten

Task/Flatten-a-list/AppleScript/flatten-a-list-2.applescript

@@ -0,0 +1,68 @@
+-- quickSort :: (Ord a) => [a] -> [a]
+on quickSort(xs)
+    set headTail to uncons(xs)
+    if headTail is not missing value then
+        set {h, t} to headTail
+
+        -- lessOrEqual :: a -> Bool
+        script lessOrEqual
+            on lambda(x)
+                x ≤ h
+            end lambda
+        end script
+
+        set {less, more} to partition(lessOrEqual, t)
+
+        quickSort(less) & h & quickSort(more)
+    else
+        xs
+    end if
+end quickSort
+
+
+-- TEST
+on run
+
+    quickSort([11.8, 14.1, 21.3, 8.5, 16.7, 5.7])
+
+    --> {5.7, 8.5, 11.8, 14.1, 16.7, 21.3}
+
+end run
+
+
+
+-- GENERIC FUNCTIONS
+
+-- partition :: predicate -> List -> (Matches, nonMatches)
+-- partition :: (a -> Bool) -> [a] -> ([a], [a])
+on partition(f, xs)
+    tell mReturn(f)
+        set lst to {{}, {}}
+        repeat with x in xs
+            set v to contents of x
+            set end of item ((lambda(v) as integer) + 1) of lst to v
+        end repeat
+        return {item 2 of lst, item 1 of lst}
+    end tell
+end partition
+
+-- uncons :: [a] -> Maybe (a, [a])
+on uncons(xs)
+    if length of xs > 0 then
+        {item 1 of xs, rest of xs}
+    else
+        missing value
+    end if
+end uncons
+
+-- Lift 2nd class handler function into 1st class script wrapper
+-- mReturn :: Handler -> Script
+on mReturn(f)
+    if class of f is script then
+        f
+    else
+        script
+            property lambda : f
+        end script
+    end if
+end mReturn

Task/Flatten-a-list/AppleScript/flatten-a-list-3.applescript

@@ -0,0 +1 @@
+{1, 2, 3, 4, 5, 6, 7, 8}

Task/Flatten-a-list/AppleScript/flatten-a-list.applescript

@@ -1,11 +0,0 @@
-my_flatten({{1}, 2, {{3, 4}, 5}, {{{}}}, {{{6}}}, 7, 8, {}})
-
-on my_flatten(aList)
-	if class of aList is not list then
-		return {aList}
-	else if length of aList is 0 then
-		return aList
-	else
-		return my_flatten(first item of aList) & (my_flatten(rest of aList))
-	end if
-end my_flatten

Task/Flatten-a-list/JavaScript/flatten-a-list-2.js

@@ -1,3 +1,18 @@
-let flatten = list => list.reduce(
-    (a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []
-);
+(function () {
+    'use strict';
+
+    // flatten :: Tree a -> [a]
+    function flatten(t) {
+        return (t instanceof Array ? concatMap(flatten, t) : t);
+    }
+
+    // concatMap :: (a -> [b]) -> [a] -> [b]
+    function concatMap(f, xs) {
+        return [].concat.apply([], xs.map(f));
+    }
+
+    return flatten(
+        [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]
+    );
+
+})();

Task/Flatten-a-list/JavaScript/flatten-a-list-3.js

@@ -0,0 +1,4 @@
+    // flatten :: Tree a -> [a]
+    function flatten(a) {
+        return a instanceof Array ? [].concat.apply([], a.map(flatten)) : a;
+    }

Task/Flatten-a-list/JavaScript/flatten-a-list-4.js

@@ -0,0 +1,13 @@
+(function () {
+    'use strict';
+
+    // flatten :: Tree a -> [a]
+    function flatten(a) {
+        return a instanceof Array ? [].concat.apply([], a.map(flatten)) : a;
+    }
+
+    return flatten(
+        [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]
+    );
+
+})();

Task/Flatten-a-list/JavaScript/flatten-a-list-5.js

@@ -0,0 +1,3 @@
+let flatten = list => list.reduce(
+    (a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []
+);

Task/Flatten-a-list/JavaScript/flatten-a-list-6.js

@@ -0,0 +1,12 @@
+function flatten(list) {
+  for (let i = 0; i < list.length; i++) {
+    while (true) {
+      if (Array.isArray(list[i])) {
+      	list.splice(i, 1, ...list[i]);
+      } else {
+      	break;
+      }
+    }
+  }
+  return list;
+}

Task/Flatten-a-list/Smalltalk/flatten-a-list-2.st

@@ -0,0 +1,18 @@
+flatDo :=
+    [:element :action |
+        element isCollection ifTrue:[
+            element do:[:el | flatDo value:el value:action]
+        ] ifFalse:[
+            action value:element
+        ].
+    ].
+
+collection := {
+                {1} . 2 . { {3 . 4} . 5 } .
+                {{{}}} . {{{6}}} . 7 . 8 . {}
+              }.
+
+newColl := OrderedCollection new.
+flatDo
+    value:collection
+    value:[:el | newColl add: el]

Task/Flatten-a-list/Smalltalk/flatten-a-list-3.st

@@ -0,0 +1 @@
+collection flatDo:[:el | newColl add:el]

Task/Flatten-a-list/Standard-ML/flatten-a-list-1.ml

@@ -0,0 +1,3 @@
+datatype 'a nestedList =
+	  L of 'a			(* leaf *)
+	| N of 'a nestedList list	(* node *)

Task/Flatten-a-list/Standard-ML/flatten-a-list-2.ml

@@ -0,0 +1,2 @@
+fun flatten (L  x) = [x]
+  | flatten (N xs) = List.concat (map flatten xs)

Task/Flatten-a-list/SuperCollider/flatten-a-list-1.supercollider

@@ -0,0 +1,3 @@
+a = [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []];
+a.flatten(1); // answers [ 1, 2, [ 3, 4 ], 5, [ [  ] ], [ [ 6 ] ], 7, 8 ]
+a.flat; // answers [ 1, 2, 3, 4, 5, 6, 7, 8 ]

Task/Flatten-a-list/SuperCollider/flatten-a-list-2.supercollider

@@ -0,0 +1,14 @@
+(
+f = { |x|
+	var res = res ?? List.new;
+	if(x.isSequenceableCollection) {
+		x.do { |each|
+			res.addAll(f.(each))
+		}
+	} {
+		res.add(x);
+	};
+	res
+};
+f.([[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]);
+)

Task/Flatten-a-list/ZX-Spectrum-Basic/flatten-a-list.zx

@@ -0,0 +1,7 @@
+10 LET f$="["
+20 LET n$="[[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8 []]"
+30 FOR i=2 TO (LEN n$)-1
+40 IF n$(i)>"/" AND n$(i)<":" THEN LET f$=f$+n$(i): GO TO 60
+50 IF n$(i)="," AND f$(LEN f$)<>"," THEN LET f$=f$+","
+60 NEXT i
+70 LET f$=f$+"]": PRINT f$