Flatten a list: Difference between revisions

{{task}}

[[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]

Where the correct result would be the list:

[1, 2, 3, 4, 5, 6, 7, 8]

 

 

=={{header|8th}}==

\ take a list (array) and flatten it:

 

(

\ is it a number?

\ yes. so add to the list

r> swap a:push >r

. cr

bye

{{out}}

[[1],2,[[3,4],5],[[[]]],[[[6]]],7,8,[]]<br>

 

=={{header|ACL2}}==

(cond ((null tr) nil)

((atom tr) (list tr))

(t (append (flatten (first tr))

 

=={{header|ActionScript}}==

var output:Array = new Array();

for (var i:uint = 0; i < input.length; i++) {

return output;

}

 

=={{header|Aikido}}==

function flatten (list, result) {

foreach item list {

println("]")

 

{{out}}

<pre>

 

=={{header|Aime}}==

show_list(list l)

{

 

o_text("[");

 

i = 0;

} else {

}

i += 1;

}

 

o_text("]");

}

 

list

{

}

 

}

 

list l;

 

 

show_list(l);

o_byte('\n');

 

o_byte('\n');

 

return 0;

{{out}}

<pre>

Flattening is built in to all of Algol68's ''transput'' routines. The following example also uses ''widening'', where scalars are converted into arrays.

 

[][][]INT list = ((1), 2, ((3,4), 5), ((())), (((6))), 7, 8, ());

print((list, new line))

{{out}}

<pre>

+1 +2 +3 +4 +5 +6 +7 +8

</pre>

 

=={{header|AppleScript}}==

 

on my_flatten(aList)

end my_flatten

 

 

{{trans|JavaScript}}

on flatten(t)

if class of t is list then

else

t

end flatten

 

on run

 

 

 

-- concatMap :: (a -> [b]) -> [a] -> [b]

on concatMap(f, xs)

set lng to length of xs

return lst

 

 

 

end script

 

 

 

=={{header|AutoHotkey}}==

AutoHotkey doesn't have built in list data type.

This examples simulates a list in a tree type object and flattens that tree.

, 2, 5), 4, object(1, object(1, object(1, object()))), 5

, object(1, object(1, 6)), 6, 7, 7, 8, 9, object())

}

return flat

 

=={{header|Bracmat}}==

A list that should not be flattened upon evaluation can be separated with dots.

 

( (myList = ((1), 2, ((3,4), 5), ((())), (((6))), 7, 8, ()))

& put$("Unevaluated:")

& lst$myList

)

 

=={{header|Brat}}==

true? my.empty?

{ [] }

list = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

p "List: #{list}"

 

=={{header|Burlesque}}==

until the Block does not contain Blocks anymore.

 

blsq ) {{1} 2 {{3 4} 5} {{{}}} {{{6}}} 7 8 {}}{\[}{)to{"Block"==}ay}w!

{1 2 3 4 5 6 7 8}

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

/* delete_list(l); delete_list(flat); */

return 0;

{{out}}

<pre>Nested: [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]

Flattened: [1, 2, 3, 4, 5, 6, 7, 8]</pre>

 

=={{header|C++}}==

#include <boost/any.hpp>

 

++current;

}

 

Use example:

Also, there's no standard way to output this type of list,

so some output code is added as well.

#include <iostream>

 

print_list(list);

std::cout << "\n";

{{out}}

<pre>

[1, 2, 3, 4, 5, 6, 7, 8]

</pre>

 

=={{header|Ceylon}}==

"Lazily flatten nested streams"

{Anything*} flatten({Anything*} stream)

print(list);

print(flatten(list).sequence());

{{out}}

<pre>

=={{header|Clojure}}==

The following returns a lazy sequence of the flattened data structure.

(lazy-seq

(when-let [s (seq coll)]

(if (coll? (first s))

(concat (flatten (first s)) (flatten (rest s)))

 

The built-in flatten is implemented as:

 

(filter (complement sequential?)

 

=={{header|CoffeeScript}}==

flatten = (arr) ->

arr.reduce ((xs, el) ->

list = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

console.log flatten list

 

Ouput:

> coffee foo.coffee

[ 1, 2, 3, 4, 5, 6, 7, 8 ]

 

=={{header|Common Lisp}}==

 

(cond ((null structure) nil)

((atom structure) (list structure))

or, from Paul Graham's OnLisp,

(defun flatten (ls)

(labels ((mklist (x) (if (listp x) x (list x))))

(mapcan #'(lambda (x) (if (atom x) (mklist x) (flatten x))) ls)))

 

Note that since, in Common Lisp, the empty list, boolean false and <code>nil</code> are the same thing, a tree of <code>nil</code> values cannot be flattened; they will disappear.

 

A third version that is recursive, imperative, and reasonably fast.

(let (result)

(labels ((grep (obj)

(grep (first obj))))))

(grep obj)

 

The following version is tail recursive and functional.

(cond ((consp x) (flatten (rest x) (cons (first x) stack) out))

(x (flatten (first stack) (rest stack) (cons x out)))

(stack (flatten (first stack) (rest stack) out))

 

The next version is imperative, iterative and does not make use of a stack. It is faster than the versions given above.

(do* ((result (list obj))

(node result))

(when (cdar node) (push (cdar node) (cdr node)))

(setf (car node) (caar node)))

The above implementations of flatten give the same output on nested proper lists.

{{Out}}

 

Which version is suitable for a given problem depends of course on the nature of the problem.

 

=={{header|D}}==

Instead of a Java-like class-based version, this version minimizes heap activity using a tagged union.

 

struct TreeList(T) {

l.writeln;

l.flatten.writeln;

{{out}}

<pre>[[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]

===With an Algebraic Data Type===

A shorter and more cryptic version.

 

alias T = Algebraic!(int, This[]);

T( T[].init )

]).flatten.writeln;

{{out}}

[1, 2, 3, 4, 5, 6, 7, 8]

 

=={{header|Déjà Vu}}==

for i in copy:

i

 

 

{{out}}

<pre>[ 1 2 3 4 5 6 7 8 ]</pre>

=={{header|E}}==

 

def flat := [].diverge()

def recur(x) {

recur(nested)

return flat.snapshot()

 

 

=={{header|EchoLisp}}==

The built-in '''(flatten list)''' is defined as follows:

(define (fflatten l)

(cond

→ ((4) (5 5 5) (6 6) (7) (8) (7 7 7) (9))

 

 

=={{header|Ela}}==

This implementation can flattern any given list:

 

flat = flat' []

| else = x :: flat' n xs

 

 

{{out}}

An alternative solution:

 

flat (x::xs)

| x is List = flat x ++ flat xs

 

=={{header|Elixir}}==

defmodule RC do

def flatten([]), do: []

# Library function

IO.inspect List.flatten(list)

{{out}}

<pre>

=={{header|Elm}}==

 

import Graphics.Element exposing (show)

 

main =

show (flatten tree)

 

=={{header|Emacs Lisp}}==

(cond

((null mylist) nil)

((atom mylist) (list mylist))

(t

 

=={{header|Erlang}}==

There's a standard function (lists:flatten/1) that does it more efficiently, but this is the cleanest implementation you could have;

flatten([H|T]) -> flatten(H) ++ flatten(T);

 

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.0}}

 

function flatten( object s )

 

? a

{{out}}

<pre>{

=={{header|F_Sharp|F#}}==

As with Haskell and OCaml we have to define our list as an algebraic data type, to be strongly typed:

| I of 'a // leaf Item

| L of 'a ll list // ' <- confine the syntax colouring confusion

printfn "%A" (flatten [L([I(1)]); I(2); L([L([I(3);I(4)]); I(5)]); L([L([L([])])]); L([L([L([I(6)])])]); I(7); I(8); L([])])

 

 

An alternative approach with List.collect

and the same data type. Note that flatten operates on all deepLists (ll) and atoms (I) are "flatened" to lists.

 

let rec flatten =

function

 

// -> [1; 2; 3; 4; 5; 6; 7; 8]

 

=={{header|Factor}}==

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|Forth}}==

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

include FMS-SILib.f

 

o{ o{ 1 } 2 o{ o{ 3 4 } 5 } o{ o{ o{ } } } o{ o{ o{ 6 } } } 7 8 o{ } }

list flatten

 

=={{header|Fortran}}==

 

! input : [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]

! flatten : [1, 2, 3, 4, 5, 6, 7, 8 ]

print *, "]"

end program

 

===Or, older style===

Fortran does not offer strings, only CHARACTER variables of some fixed size. Functions can return such types, but, must specify a fixed size. Or, mess about with run-time allocation as above. Since in principle a list is arbitrarily long, the plan here is to crush its content in place, and thereby never have to worry about long-enough work areas. This works because the transformations in mind never replace something by something longer. A subroutine can receive an arbitrary-sized CHARACTER variable, and can change it. No attempt is made to detect improper lists.

SUBROUTINE CRUSH(LIST) !Changes LIST.

Crushes a list holding multi-level entries within [...] to a list of single-level entries. Null entries are purged.

CALL CRUSH(STUFF) !Can't be a constant, as it will be changed.

WRITE (6,*) " Crushed: ",STUFF !Behold!

Output is

Original: [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

 

=={{header|Frink}}==

a = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

println[flatten[a]]

 

=={{header|GAP}}==

 

=={{header|Go}}==

 

import "fmt"

}

return

{{out}}

<pre>

In the code above, flatten uses an easy-to-read type switch to extract ints and return an int slice. The version below is generalized to return a flattened slice of interface{} type, which can of course refer to objects of any type, and not just int.

Also, just to show a variation in programming style, a type assertion is used rather than a type switch.

for _, e := range s {

if i, ok := e.([]interface{}); ok {

}

return

 

=={{header|Groovy}}==

<code>List.flatten()</code> is a Groovy built-in that returns a flattened copy of the source list:

 

 

=={{header|Haskell}}==

In Haskell we have to interpret this structure as an algebraic data type.

 

 

-- [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

-- implemented as multiway tree:

-- Data.Tree represents trees where nodes have values too, unlike the trees in our problem.

-- so we use a list as that value, where a node will have an empty list value,

-- and a leaf will have a one-element list value and no subtrees

list :: Tree [Int]

 

 

 

flatten :: Tree a -> [a]

flatten (Leaf x) = [x]

 

Yet another choice, custom data structure, efficient lazy flattening:

(This is unnecessary; since Haskell is lazy, the previous solution will only do just as much work as necessary for each element that is requested from the resulting list.)

 

 

flatten :: NestedList a -> [a]

where

 

example :: NestedList Int

 

main :: IO ()

main = print $ flatten example

 

 

=={{header|Icon}} and {{header|Unicon}}==

The following procedure solves the task using a string representation of nested lists and cares not if the list is well formed or not.

 

procedure sflatten(s) # uninteresting string solution

return pretrim(trim(compress(deletec(s,'[ ]'),',') ,','),',')

{{libheader|Icon Programming Library}}

The solution uses several procedures from [http://www.cs.arizona.edu/icon/library/src/procs/strings.icn strings in the IPL]

 

This procedure is more in the spirit of the task handling actual lists rather than representations. It uses a recursive approach using some of the built-in list manipulation functions and operators.

local l,x

 

else put(l,x)

return l

 

Finally a demo routine to drive these and a helper to show how it works.

write(sflatten(" [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]"))

writelist(flatten( [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]))

write(" ]")

return

 

=={{header|Ioke}}==

[[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []] flatten

 

=={{header|J}}==

 

'''Solution''':

 

'''Example''':

]li =. (<1) ; 2; ((<3; 4); 5) ; ((<a:)) ; ((<(<6))) ; 7; 8; <a:

+---+-+-----------+----+-----+-+-+--+

 

flatten li

 

'''Notes:'''

'''Alternative Solution:'''<br>

The previous solution can be generalized to flatten the nesting and shape for a list of arbitrary values that include arrays of any rank:

 

'''Example:'''

+---+-+---------------------+----+------+--+--+--+

|+-+|2|+-------+-----------+|+--+|+----+|18|19|++|

1 2 3 4 5 6 7 8

flatten2 li2

 

Here, we have replaced <code><S:0</code> with <code><@,S:0</code> so our leaves are flattened before the final step where their boxes are razed.

 

Actual Workhorse code

import java.util.List;

 

}

}

 

Method showing population of the test List and usage of flatten method.

import java.util.List;

 

return asList(a);

}

 

{{out}}

;Functional version

{{works with|Java|8+}}

import java.util.stream.Stream;

import java.util.stream.Collectors;

return flattenToStream(list).collect(Collectors.toList());

}

 

=={{header|JavaScript}}==

===ES5===

return list.reduce(function (acc, val) {

return acc.concat(val.constructor === Array ? flatten(val) : val);

}, []);

 

 

Or, expressed in terms of the more generic '''concatMap''' function:

 

'use strict';

 

);

 

 

{{Out}}

 

===ES6===

 

Result is always:

 

=={{header|Joy}}==

"seqlib" libload.

 

 

(* output: [1 2 3 4 5 6 7 8] *)

 

=={{header|jq}}==

reduce .[] as $i

([];

if $i | type == "array" then . + ($i | flatten)

else . + [$i]

[[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []] | flatten

 

{{out}}

<pre>

</pre>

 

 

So to flatten a list of arbitrary depth, you can join-over-over, or reduce a list with a function that reduces a list with a join function:

 

 

=={{header|Lasso}}==

Lasso Delve is a Lasso utility method explicitly for handling embedded arrays. With one array which contain other arrays, delve allows you to treat one array as a single series of elements, thus enabling easy access to an entire tree of values. [http://www.lassosoft.com/lassoDocs/languageReference/obj/delve www.lassosoft.com/lassoDocs/languageReference/obj/delve Lasso reference on Delve]

 

 

#original

'<br />'

(with item in delve(#original)

<pre>array(array(1), 2, array(array(3, 4), 5), array(array(array())), array(array(array(6))), 7, 8, array())

staticarray(1, 2, 3, 4, 5, 6, 7, 8)</pre>

 

=={{header|LFE}}==

> (: lists flatten '((1) 2 ((3 4) 5) ((())) (((6))) 7 8 ()))

(1 2 3 4 5 6 7 8)

 

=={{header|Logtalk}}==

flatten(List, [], Flatted).

 

flatten(Tail, List, Aux),

flatten(Head, Aux, Flatted).

 

=={{header|Lua}}==

 

if type(list) ~= "table" then return {list} end

local flat_list = {}

test_list = {{1}, 2, {{3,4}, 5}, {{{}}}, {{{6}}}, 7, 8, {}}

 

 

=={{header|Maple}}==

This can be accomplished using the <code>Flatten</code> command from the <code>ListTools</code>, or with a custom recursive procedure.

 

L := [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]:

 

 

Flatten(L);

{{out}}

<pre>

</pre>

 

flatten := proc(x)

`if`(type(x,'list'),seq(procname(i),i = x),x);

 

[flatten(L)];

{{out}}

<pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|Maxima}}==

 

=={{header|Mercury}}==

As with Haskell we need to use an algebraic data type.

:- interface.

 

 

:- end_module flatten_a_list.

{{out}}

<pre>

[1, 2, 3, 4, 5, 6, 7, 8]

</pre>

 

=={{header|Mirah}}==

import java.util.List

import java.util.Collection

source = [[1], 2, [[3, 4], 5], [[ArrayList.new]], [[[6]]], 7, 8, ArrayList.new]

 

 

=={{header|NewLISP}}==

(1 2 3 4 5 6 7 8)

 

=={{header|NGS}}==

NGS defines '''flatten''' as a shallow flatten, hence using '''flatten_r''' here.

 

collector {

local kern

}

 

 

{{out}}

 

=={{header|Nim}}==

case isLeaf: bool

of false: list: seq[TreeList[T]]

 

proc L[T](list: varargs[TreeList[T]]): TreeList[T] =

 

proc N[T](data: T): TreeList[T] =

TreeList[T](isLeaf: true, data: data)

 

proc flatten[T](n: TreeList[T]): seq[T] =

if n.isLeaf: result = @[n.data]

else:

for x in n.list:

result.add flatten x

 

var x = L(L(N 1), N 2, L(L(N 3, N 4), N 5), L(L(L[int]())), L(L(L(N 6))), N 7, N 8, L[int]())

{{out}}

 

=={{header|Objective-C}}==

{{works with|Cocoa}}

 

@interface NSArray (FlattenExt)

return 0;

 

=={{header|OCaml}}==

val flatten : 'a list list -> 'a list = <fun>

 

# (* use another data which can be accepted by the type system *)

flatten [[1]; [2; 3; 4]; []; [5; 6]; [7]; [8]] ;;

 

Since OCaml is statically typed, it is not possible to have a value that could be both a list and a non-list. Instead, we can use an algebraic datatype:

 

type 'a tree = Leaf of 'a | Node of 'a tree list

 

 

# flatten (Node [Node [Leaf 1]; Leaf 2; Node [Node [Leaf 3; Leaf 4]; Leaf 5]; Node [Node [Node []]]; Node [Node [Node [Leaf 6]]]; Leaf 7; Leaf 8; Node []]) ;;

 

=={{header|Oforth}}==

 

 

{{out}}

</pre>

 

=={{header|ooRexx}}==

sub1 = .array~of(1)

sub2 = .array~of(3, 4)

else accumulator~append(item)

end

 

=={{header|PARI/GP}}==

my(u=[]);

for(i=1,#v,

);

u

 

=={{header|Perl}}==

map { ref eq 'ARRAY' ? flatten(@$_) : $_ } @_

}

 

my @lst = ([1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []);

 

=={{header|Phix}}==

standard builtin

{{out}}

<pre>

{1,2,3,4,5,6,7,8}

</pre>

 

=={{header|PHP}}==

{{works with|PHP|4.x only, not 5.x}}

It won't work on PHP 5 due to the change in behavior of array_merge(). */

while (array_filter($lst, 'is_array'))

Explanation: while <code>$lst</code> has any elements which are themselves arrays (i.e. <code>$lst</code> is not flat), we merge the elements all together (in PHP 4, <code>array_merge()</code> treated non-array arguments as if they were 1-element arrays; PHP 5 <code>array_merge()</code> no longer allows non-array arguments.), thus flattening the top level of any embedded arrays. Repeat this process until the array is flat.

 

===Recursive===

 

function flatten($ary) {

$result = array();

$lst = array(array(1), 2, array(array(3, 4), 5), array(array(array())), array(array(array(6))), 7, 8, array());

var_dump(flatten($lst));

 

Alternatively:{{works with|PHP|5.3+}}

 

function flatten($ary) {

$result = array();

$lst = array(array(1), 2, array(array(3, 4), 5), array(array(array())), array(array(array(6))), 7, 8, array());

var_dump(flatten($lst));

 

function flatten_helper($x, $k, $obj) {

$obj->flattened[] = $x;

$lst = array(array(1), 2, array(array(3, 4), 5), array(array(array())), array(array(array(6))), 7, 8, array());

var_dump(flatten($lst));

 

Using the standard library (warning: objects will also be flattened by this method):

 

$lst = array(array(1), 2, array(array(3, 4), 5), array(array(array())), array(array(array(6))), 7, 8, array());

$result = iterator_to_array(new RecursiveIteratorIterator(new RecursiveArrayIterator($lst)), false);

var_dump($result);

 

===Non-recursive===

 

Function flat is iterative and flattens the array in-place.

function flat(&$ary) { // argument must be by reference or array will just be copied

for ($i = 0; $i < count($ary); $i++) {

flat($lst);

var_dump($lst);

 

=={{header|PicoLisp}}==

(make # Build a list

(recur (X) # recursively over 'X'

(if (atom X)

(link X) # Put atoms into the result

 

or a more succint way using [http://www.software-lab.de/doc/refF.html#fish fish]:

 

 

=={{header|Pike}}==

There's a built-in function called <code>Array.flatten()</code> which does this, but here's a custom function:

array r = ({ });

return r;

 

=={{header|PL/I}}==

The Translate(text,that,this) intrinsic function returns ''text'' with any character in ''text'' that is found in ''this'' (say the third) replaced by the corresponding third character in ''that''. Suppose the availability of a function Replace(text,that,this) which returns ''text'' with all occurrences of ''this'' (a single text, possibly many characters) replaced by ''that'', possibly zero characters. The Translate function does not change the length of its string, simply translate its characters in place.

list = translate (list, ' ', '[]' ); /*Produces " 1 , 2, 3,4 , 5 , , 6 , 7, 8, " */

list = Replace(list,'',' '); /*Converts spaces to nothing. Same parameter order as Translate.*/

end; /*And search afresh, in case of multiple commas in a row.*/

list = '[' || list || ']'; /*Repackage the list.*/

This is distinctly crude. A user-written Replace function is confronted by the requirement to specify a maximum size for its returned result, for instance <code>Replace:Procedure(text,that,this) Returns(Character 200 Varying);</code> which is troublesome for general use. The intrinsic function Translate has no such restriction.

 

=={{header|PostScript}}==

{{libheader|initlib}}

/flatten {

/.f {{type /arraytype eq} {{.f} map aload pop} ift}.

[exch .f]

}.

[[1] 2 [[3 4] 5] [[[]]] [[[6]]] 7 8 []] flatten

 

=={{header|PowerShell}}==

function flatten($a) {

if($a.Count -gt 1) {

$a = @(@(1), 2, @(@(3,4), 5), @(@(@())), @(@(@(6))), 7, 8, @())

"$(flatten $a)"

<b>Output:</b>

<pre>

 

=={{header|Prolog}}==

flatten(List, FlatList) :-

flatten(List, [], FlatList).

 

flatten(NonList, T, [NonList|T]).

 

=={{header|Python}}==

===Recursive===

return sum( ([x] if not isinstance(x, list) else flatten(x)

for x in lst), [] )

>>> lst = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

>>> flatten(lst)

 

 

Function flat is iterative and flattens the list in-place. It follows the Python idiom of returning None when acting in-place:

i=0

while i<len(lst):

>>> flat(lst)

>>> lst

 

===Generative===

In this case, the generator is converted back to a list before printing.

 

for x in lst:

if isinstance(x, list):

>>> lst = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

>>> print list(flatten(lst))

 

 

 

 

=={{header|Racket}}==

Racket has a built-in flatten function:

#lang racket

(flatten '(1 (2 (3 4 5) (6 7)) 8 9))

{{out}}

<pre>

 

or, writing it explicitly with the same result:

#lang racket

(define (flatten l)

[else (append (flatten (first l)) (flatten (rest l)))]))

(flatten '(1 (2 (3 4 5) (6 7)) 8 9))

 

=={{header|REBOL}}==

flatten: func [

"Flatten the block in place."

head block

]

 

Sample: <pre>

</pre>

 

 

 

 

 

 

=={{header|Ring}}==

next

 

=={{header|Ruby}}==

<code>flatten</code> is a built-in method of Arrays

The <code>flatten</code> method takes an optional argument, which dedicates the amount of levels to be flattened.

# => [1, 2, [3, 4], 5, [[]], [[6]], 7, 8]

 

 

=={{header|S-lang}}==

 

define flatten (list) {

}

return retval;

 

Sample:

 

=={{header|Scala}}==

case Nil => Nil

case (head: List[_]) :: tail => flatList(head) ::: flatList(tail)

case head :: tail => head :: flatList(tail)

 

Sample:

 

=={{header|Scheme}}==

(cond ((null? x) '())

((not (pair? x)) (list x))

 

> (flatten '((1) 2 ((3 4) 5) ((())) (((6))) 7 8 ()))

 

=={{header|Sidef}}==

a.each { |item|

}

 

 

=={{header|Slate}}==

[

[| :out | s flattenOn: out] writingAs: s

ifTrue: [value flattenOn: w]

ifFalse: [w nextPut: value]].

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

 

flatten [ |f|

f := OrderedCollection new.

{{{}}} . {{{6}}} . 7 . 8 . {} }.

 

 

Here is a non-OOP (but functional) version, which uses a block-closure as function (showing higher order features of Smalltalk):

 

flatDo :=

[:element :action |

flatDo

value:collection

 

of course, many Smalltalk libraries already provide such functionality.

{{works with|Smalltalk/X}} {{works with|Pharo}}

 

=={{header|Standard ML}}==

In Standard ML, list must be homogeneous, but nested lists can be implemented as a tree-like data structure using a <code>datatype</code> statement:

L of 'a (* leaf *)

| N of 'a nestedList list (* node *)

Flattening of this structure is similar to flatten trees:

 

{{out}}

 

=={{header|Suneido}}==

 

{{out}}

<pre>#(1, 2, 3, 4, 5, 6, 7, 8)</pre>

 

 

 

return s

}

println(s)

let result : [Int] = flatten(s)

{{out}}

<pre>

More functionally:

{{works with|Swift|1.2+}}

return s

}

println(s)

let result : [Int] = flatten(s)

{{out}}

<pre>

</pre>

 

{{works with|Swift|2.0+}}

{

return s

let result: [Int] = flatten(input)

 

{{out}}

<pre>

[[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]

[1, 2, 3, 4, 5, 6, 7, 8]

</pre>

 

=={{header|Tcl}}==

for {set old {}} {$old ne $list} {} {

set old $list

 

puts [flatten {{1} 2 {{3 4} 5} {{{}}} {{{6}}} 7 8 {}}]

Note that because lists are not syntactically distinct from strings, it is probably a mistake to use this procedure with real (especially non-numeric) data. Also note that there are no parentheses around the outside of the list when printed; this is just a feature of how Tcl regards lists, and the value is a proper list (it can be indexed into with <code>lindex</code>, iterated over with <code>foreach</code>, etc.)

 

Another implementation that's slightly more terse:

 

while { $data != [set data [join $data]] } { }

return $data

}

puts [flatten {{1} 2 {{3 4} 5} {{{}}} {{{6}}} 7 8 {}}]

 

 

 

=={{header|TXR}}==

An important builtin.

@(bind bar foo)

 

Run:

bar[6]="7"

bar[7]="8"</pre>

 

=={{header|VBScript}}==

 

=====Implementation=====

class flattener

dim separator

end property

end class

 

=====Invocation=====

dim flat

set flat = new flattener

flat.itemSeparator = "~"

wscript.echo join( flat.flatten( array( array( 1 ),2,array(array(3,4),5),array(array(array())),array(array(array(6))),7,8,array())), "!")

 

{{out}}

=====Alternative (classless) Version=====

{{works with|Windows Script Host|*}}

' Flatten the example array...

a = FlattenArray(Array(Array(1), 2, Array(Array(3,4), 5), Array(Array(Array())), Array(Array(Array(6))), 7, 8, Array()))

Next

End Sub

 

=={{header|Wart}}==

Here's how Wart implements <code>flatten</code>:

if no.seq

acc

(cons seq acc)

:else

 

{{out}}

<pre>(flatten '((1) 2 ((3 4) 5) ((())) (((6))) 7 8 ()))

=> (1 2 3 4 5 6 7 8)</pre>

 

=={{header|zkl}}==

flatten(L(L(1), L(2), L(L(3,4), 5), L(L(L())), L(L(L(6))), 7, 8, L()))

This works by recursively writing the contents of lists to a new list. If a list is recursive or cyclic, it will blow the stack and throw an exception.