Brace expansion: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

V out = [‘’]

L s != ‘’

{,{,gotta have{ ,\, again\, }}more }cowbell!

{}} some }{,{\\{ edge, edge} \,}{ cases, {here} \\\\\}’.split("\n")

{{out}}

<pre>

This may seem like a cheat, but it ''is'' a legitimate and obvious way to tackle the problem with AppleScript in the unlikely event that the need should arise. It adjusts the escape levels in the input text, feeds it as a shell script to macOS's sh shell, and lets ''it'' handle the expansion.

use framework "Foundation"

use scripting additions

set AppleScript's text item delimiters to astid

{{output}}

=={{header|AutoHotkey}}==

BraceExp(string, del:="`n") {

Loop, Parse, string

Msgbox, % BraceExp("apple {bush,tree}")

Msgbox, % BraceExp("h{i,ello}")

{{out}}

<pre>enable_video

=={{header|C}}==

Handles only properly formed input.

#include <stdio.h>

#include <stdlib.h>

return 0;

{{out}}

<pre>Pattern: ~/{Downloads,Pictures}/*.{jpg,gif,png}

C++11 solution:

#include <iterator>

#include <string>

return 0;

=={{header|C sharp|C#}}==

This approach turns the string into a tree structure, with Tokens that are either text, a concatenation or an alteration.

{{works with|C sharp|8}}

using System.Collections;

using System.Collections.Generic;

return result;

}

{{trans|Python}}

{

const char L = '{', R = '}', S = ',';

return (null, "");

}

{{out}}

<pre>

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

(alternatives nil :type list))

(dolist (output (expand input))

(format t " ~A~%" output))

{{out}}

<pre>~/{Downloads,Pictures}/*.{jpg,gif,png}

{{trans|Python}}

This code is not UTF-corrected, because it uses slicing instead of front, popFront, etc.

Nullable!(Tuple!(string[], string)) getGroup(string s, in uint depth)

foreach (const s; testCases.splitLines)

writefln("%s\n%-( %s\n%)\n", s, s.getItems[0]);

{{out}}

<pre>~/{Downloads,Pictures}/*.{jpg,gif,png}

=={{header|Elixir}}==

{{trans|Ruby}}

def getitem(s), do: getitem(String.codepoints(s), 0, [""])

|> Enum.each(fn str -> IO.puts "\t#{str}" end)

IO.puts ""

{{out}}

=={{header|Go}}==

<code>expand.go</code>:

// Expander is anything that can be expanded into a slice of strings.

alt = append(alt, sub)

return alt

<code>expand_test.go</code>

import (

Expand(input)

}

{{out}}

<pre>

=={{header|Groovy}}==

{{trans|Java}}

static void main(String[] args) {

for (String s : [

}

}

{{out}}

<pre>Itemized, please.

[http://www.reddit.com/r/readablecode/comments/1w6exe/p6_crosswalk_braceexpansionparses/cf229at "Here is a direct translation to Haskell using parsec"] (of [http://rosettacode.org/mw/index.php?title=Brace_expansion&oldid=175567#Raku an earlier version of the Raku solution]):

showExpansion :: String -> String

, "{,{,gotta have{ ,\\, again\\, }}more }cowbell!"

, "{}} some }{,{\\\\{ edge, edge} \\,}{ cases, {here} \\\\\\\\\\}"

{{out}}

<pre>It{{em,alic}iz,erat}e{d,}, please.

Implementation:

NB. legit { , and } do not follow a legit backslash:

legit=: 1,_1}.4>(3;(_2[\"1".;._2]0 :0);('\';a.);0 _1 0 1)&;:&.(' '&,)

options=. }:mask <;._1 y

prefix,each options,each suffix

Examples:

~/Downloads/*.jpg

~/Downloads/*.gif

>expand t4

{}} some {\\edge }{ cases, here\\\}

Explanation:

=={{header|Java}}==

Should be able to handle all printable Unicode.

public static void main(String[] args) {

}

}

<pre>Itemized, please.

Each node of the parse tree consists of one of two simple functions (AND: syntagmatic concatenation, OR: flattening of paradigms) with a set of arguments, each of which may be a plain string or an AND or OR subtree. The expansions are derived by evaluating the parse tree as an expression.

'use strict'

}).join('\n\n');

Value returned by function:

Sample of parse trees logged to the console:

"fn": "[function and]",

"args": [

" please."

]

=={{header|Julia}}==

out = [""]

while s != ""

println(ans)

end

~/{Downloads,Pictures}/*.{jpg,gif,png}

--------------------------------------------

=={{header|Kotlin}}==

{{trans|Java}}

object BraceExpansion {

BraceExpansion.expand(s)

}

{{out}}

Note that this code isn't very memory efficient.

local itemsWrapped = {}

end

print()

{{out}}

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

(*A few named constants for readability.*)

(*Data was stored in a local file.*)

<pre>~/{Downloads,Pictures}/*.{jpg,gif,png}

It{{em,alic}iz,erat}e{d,}, please.

=={{header|Nim}}==

{{trans|Seed7}}

var

"{}} some }{,{\\\\{ edge, edge} \\,}{ cases, {here} \\\\\\\\\\}"]:

echo "\nExpansions of \"", str, "\":"

{{out}}

So here is a manual solution that implements the specification precisely:

my $input = shift;

my @stack = ([my $current = ['']]);

return @$current;

Usage demonstration:

chomp($input);

print "$input\n";

It{{em,alic}iz,erat}e{d,}, please.

{,{,gotta have{ ,\, again\, }}more }cowbell!

{{out}}

<pre>

=={{header|Phix}}==

Fairly straightforward recursive solution

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Brace_expansion.exw</span>

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #000000;">edump</span><span style="color: #0000FF;">(</span><span style="color: #000000;">brarse</span><span style="color: #0000FF;">(</span><span style="color: #008000;">`{,{,gotta have{ ,\, again\, }}more }cowbell!`</span><span style="color: #0000FF;">))</span>

<span style="color: #000000;">edump</span><span style="color: #0000FF;">(</span><span style="color: #000000;">brarse</span><span style="color: #0000FF;">(</span><span style="color: #008000;">`{}} some }{,{\\{ edge, edge} \,}{ cases, {here} \\\\\}`</span><span style="color: #0000FF;">))</span>

{{Out}}

<pre>

=={{header|PHP}}==

{{trans|Python}}

$out = [''];

while ($s) {

printf(" %s\n", $expansion);

}

{{out}}

<pre>

=={{header|PicoLisp}}==

(let Lst

(make

(if (pair (car Lst))

(mapcan recurse (car Lst))

Test:

(quote

"~/Downloads/*.jpg"

"{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}"

"{}} some }{,{\\ edge \,}{ cases, {here} \\\\\}" )

=={{header|PowerShell}}==

{{works with|PowerShell|2}}

function Expand-Braces ( [string]$String )

{

}

}

$TestStrings = @(

'It{{em,alic}iz,erat}e{d,}, please.'

Expand-Braces $String

}

{{out}}

<pre>

=={{header|Prolog}}==

sym(',', commalist) --> ['\\',','], !.

sym(H, Context) --> [H], { not(H = '{'; H = '}'), (Context = commalist -> not(H = ','); true) }.

brace_expansion(In, Out) :- atom_chars(In, Chars), findall(Out,grammar(Out, Chars, []), List), list_to_set(List, Out).

Testing:

?- brace_expansion("~/{Downloads,Pictures}/*.{jpg,gif,png}", Out).

Out = ["~/Downloads/*.jpg","~/Downloads/*.gif","~/Downloads/*.png","~/Pictures/*.jpg","~/Pictures/*.gif","~/Pictures/*.png"].

Out = ["cowbell!", "more cowbell!", "gotta have more cowbell!", "gotta have, again, more cowbell!"].

=={{header|Python}}==

out = [""]

while s:

{,{,gotta have{ ,\, again\, }}more }cowbell!

{}} some }{,{\\\\{ edge, edge} \,}{ cases, {here} \\\\\\\\\}'''.split('\n'):

{{out}}

=={{header|Racket}}==

{{trans|Python}}

(require racket/match)

(define (merge-lists as . bss)

))

(for ((s (in-list patterns)) #:when (printf "expand: ~a~%" s) (x (in-list (brace-expand s))))

{{out}}

<pre>expand: ~/{Downloads,Pictures}/*.{jpg,gif,png}

On the other end, we recursively walk the parse tree returning expanded sublists, and we do the cartesian concatenation of sublists at each level by use of the <tt>X~</tt> operator, which is a "cross" metaoperator used on a simple <tt>~</tt> concatenation. As a list infix operator, <tt>X~</tt> does not care how many items are on either side, which is just what you want in this case, since some of the arguments are strings and some are lists. Here we use a fold or reduction form in square brackets to interpose the cross-concat between each value generated by the map, which returns a mixture of lists and literal strings. One other thing that might not be obvious: if we bind to the match variable, <tt>$/</tt>, we automatically get all the syntactic sugar for its submatches. In this case, <tt>$0</tt> is short for <tt>$/[0]</tt>, and represents all the submatches captured by 0th set of parens in either <tt>TOP</tt> or <tt>alt</tt>. <tt>$&lt;meta&gt;</tt> is likewise short for <tt>$/&lt;meta&gt;</tt>, and retrieves what was captured by that named submatch.

token TOP { ( <meta> | . )* }

token meta { '{' <alts> '}' | \\ . }

a{b,{{c}}

{a{\}b,c}d

{{out}}

<pre>~/{Downloads,Pictures}/*.{jpg,gif,png}

=={{header|REXX}}==

* Brace expansion

* 26.07.2016

Say arg(1) /* show on screen */

Call lineout oid,arg(1) /* write to file */

{{out}}

<pre>J:\>rexx braces

=={{header|Ruby}}==

{{trans|Python}}

out = [""]

until s.empty?

puts getitem(s)[0].map{|str| "\t"+str}

puts

{{out}}

=={{header|Rust}}==

const CLOSE_CHAR: char = '}';

const SEPARATOR: char = ',';

println!("{}", line);

}

{{trans|Python}}

fn main() {

let input = "~/{Downloads,Pictures}/*.{jpg,gif,png}

None

}

{{out}}

=={{header|Scala}}==

{{works with|Scala|2.11}}

import collection.mutable.ListBuffer

case class State(isChild: Boolean, alts: ListBuffer[String], rem: List[Char])

parseElem(State(false, ListBuffer(""), s.toList)).alts

}

Demonstrating:

println(expand("""~/{Downloads,Pictures}/*.{jpg,gif,png}""") mkString "\n")

println(expand("It{{em,alic}iz,erat}e{d,}, please.") mkString "\n")

println(expand("""{,{,gotta have{ ,\, again\, }}more }cowbell!""") mkString "\n")

println(expand("""{}} some }{,{\\{ edge, edge} \,}{ cases, {here} \\\\\}""") mkString "\n")

{{out}}

<pre>

=={{header|Scheme}}==

(define (parse-brackets str)

;; We parse the bracketed strings using an accumulator and a stack

(bracket-expand "It{{em,alic}iz,erat}e{d,}")

;; '("Ited" "Ite" "Itemed" "Iteme" "Italiced" "Italice" "Itized" "Itize" "Iterated" "Iterate")

=={{header|Seed7}}==

const proc: expandBraces (in string: stri) is func

expandBraces(stri);

end for;

{{out}}

=={{header|Sidef}}==

{{trans|Perl}}

var current = ['']

var stack = [[current]]

It{{em,alic}iz,erat}e{d,}, please.

{,{,gotta have{ ,\, again\, }}more }cowbell!

{{out}}

<pre>

=={{header|Simula}}==

{{trans|Python}}

BEGIN

END;

ARRAYLISTS

BEGIN

END

{{out}}

<pre>~/{Downloads,Pictures}/*.{jpg,gif,png}

=={{header|Tailspin}}==

templates braceExpansion

composer braceParse

'{}} some }{,{\\{ edge, edge} \,}{ cases, {here} \\\\\}' -> '"$;" expands to $ -> braceExpansion ... -> '$#10;$;';$#10;$#10;' -> !OUT::write

{{out}}

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

proc combine {cases1 cases2 {insert ""}} {

}

return $current

Demonstrating:

"~/{Downloads,Pictures}/*.{jpg,gif,png}"

"It{{em,alic}iz,erat}e{d,}, please."

} {

puts $testcase\n\t[join [commatize $testcase] \n\t]

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|Python}}

Function GetGroup(s As String, depth As Integer) As Tuple(Of List(Of String), String)

End Sub

{{out}}

<pre>It{{em,alic}iz,erat}e{d,}, please.

=={{header|Wren}}==

{{trans|Python}}

var getItem = Fn.new { |s, depth|

for (s in getItem.call(input, 0)[0]) System.print(" " + s)

System.print()

{{out}}

=={{header|zkl}}==

This is a two pass algorithm (2*length(string)), one pass to find valid {} pairs, the next pass to expand them.

cs:=L();

foreach c in (code){ // start fresh or continue (if recursing)

}

strings

"It{{em,alic}iz,erat}e{d,}, please.", "a{2,1}b{X,Y,X}c", 0'|a\\{\\\{b,c\,d}|,

"{a,b{c{,{d}}e}f", 0'|{,{,gotta have{ ,\, again\, }}more }cowbell!|,

{

"%s expands to\n %s".fmt(bs,expando(bs)).println();

{{out}}

<pre>