Brace expansion using ranges: Difference between revisions

 

 

Write and test a function which expands one or more Unix-style '''numeric and alphabetic range braces''' embedded in a larger string.<br><br>

{{task heading|Tests}}

 

 

The JavaScript implementation below uses parser combinators, aiming to encode a more or less full and legible description of the <pre><PREAMBLE><AMBLE><POSTSCRIPT></pre> range brace grammar, but you should use any resource that suggests itself in your language, including parser libraries.

(The grammar of range expansion, unlike that of nested list expansion, is not recursive, so even regular expressions should prove serviceable here).

 

 

<pre>simpleNumberRising{1..3}.txt ->

minusSignFlipsSequence 025.txt

minusSignFlipsSequence 030.txt

 

combined-{Q..P}{2..1}.txt ->

* &nbsp; [[Range_expansion|range expansion]]

<br><br>

 

=={{header|Go}}==

{{trans|Wren}}

 

import (

"unicode/utf8"

)

 

func parseRange(r string) []string {

if n3 < 0 {

asc = !asc

n3 = -n3

}

"steppedDownAndPadded-{10..00..5}.txt",

"minusSignFlipsSequence {030..20..-5}.txt",

"combined-{Q..P}{2..1}.txt",

"emoji{🌵..🌶}{🌽..🌾}etc",

"steppedAlphaRising{P..Z..2}.txt",

"stops after endpoint-{02..10..3}.txt",

}

for _, s := range examples {

fmt.Println()

}

 

{{out}}

Same as Wren entry.

</pre>

=={{header|JavaScript}}==

 

 

// braceExpandWithRange :: String -> [String]

braceRangeExpansion()

))(s);

return 0 < expansions.length ? (() => {

return suffixAdd(

parsed.reduce(

uncurry(suffixMultiply),

)

})() : [s];

};

 

 

 

// braceRangeExpansion :: [String]

affixLeaf(),

fmapP(xs => [xs])(

altP(

numericSequence()

 

 

// main :: IO ()

const main = () => {

const tests = [

];

 

};

 

 

 

// affixLeaf :: () -> Parser String

// characters before or after a pair of braces.

fmapP(cs => [

])(

);

 

fmapP(ab => {

const [from, to] = ab;

return from !== to ? (

enumFromThenToChar(from)(

})(

ordinalRange(satisfy(

))

);

[from, to, by] = triple.map(

sn => (sn[0] ? negate : identity)(

)

);

return map(

)(

);

};

// The String component contains the digits.

bindP(

)(sign => bindP(

some(digit())

option(Tuple(false)(1))(

bindP(

numericPart()

)(pureP))

p

)(from => bindP(

p

)(compose(pureP, append([from])))));

(a, x) => (0 < a) || (1 > x.length) ? (

a

0

);

 

 

 

// Parser :: String -> [(a, String)] -> Parser a

// A function lifted into a Parser object.

({

parser: f

});

q => Parser(s => {

const xs = parse(p)(s);

return 0 < xs.length ? (

xs

p => Parser(

s => parse(pf)(s).flatMap(

)

);

pClose => p => bindP(

pOpen

p

)(x => bindP(

pClose

 

 

f => Parser(

s => parse(p)(s).flatMap(

)

);

const char = x =>

// A particular single character.

 

 

const emptyP = () =>

// The empty list.

 

 

// escape :: Parser String

const escape = () =>

);

 

p => Parser(

s => parse(p)(s).flatMap(

)

);

const item = () =>

// A single character.

 

 

// Lifts a parser for a simple type of value

// to a parser for a list of such values.

liftA2P(

x => xs => [x].concat(xs)

return Parser(

s => parse(

0 < s.length ? (

) : pureP([])

)(s)

const parse = p =>

// The result of parsing s with p.

 

 

// Any character for which the

// given predicate returns true.

] : []

 

// sequenceP :: [Parser a] -> Parser [a]

s => ps.reduce(

(a, q) => a.flatMap(

)

),

// Lifts a parser for a simple type of value

// to a parser for a list of such values.

return Parser(

s => parse(

liftA2P(

x => xs => [x].concat(xs)

)(s)

);

const string = s =>

// A particular string.

sequenceP([...s].map(char))

);

 

 

 

// Tuple (,) :: a -> b -> (a, b)

const Tuple = a =>

b => ({

});

 

 

 

// concat :: [[a]] -> [a]

 

 

// enumFromThenTo :: Int -> Int -> Int -> [Int]

return Array.from({

};

 

.map(x => x.codePointAt(0)),

d = i2 - i1;

return Array.from({

length: (Math.floor(iY - i2) / d) + 2

// A simple function lifted to one which applies

// to a tuple, transforming only its first item.

 

 

// flip :: (a -> b -> c) -> b -> a -> c

const flip = op =>

// its arguments reversed.

1 < op.length ? (

(a, b) => op(b, a)

) : (x => y => op(y)(x));

 

 

// fromEnum :: Enum a => a -> Int

const fromEnum = x =>

x.constructor === Object ? (

x.value

) : x.codePointAt(0);

 

// The identity function. (`id`, in Haskell)

x;

 

 

const isDigit = c => {

const n = c.codePointAt(0);

return 48 <= n && 57 >= n;

};

s.padStart(n, c)

) : s;

 

 

const maxBound = x => {

const e = x.enum;

return Boolean(e) ? (

e[e[x.max]]

) : {

} [typeof x];

};

const minBound = x => {

const e = x.enum;

return Boolean(e) ? (

e[e[0]]

) : {

} [typeof x];

};

const pred = x => {

const t = typeof x;

const [i, mn] = [x, minBound(x)].map(fromEnum);

return i > mn ? (

toEnum(x)(i - 1)

})() : x > Number.MIN_SAFE_INTEGER ? (

x - 1

};

 

 

 

 

const str = x =>

Array.isArray(x) && x.every(

) ? (

) : x.toString();

 

const succ = x => {

const t = typeof x;

1 + x

};

 

// allowing the function to make the right mapping

x => ({

} [typeof e])(x);

 

// A function over a pair, derived

// from a curried function.

const

xy = Boolean(args.length % 2) ? (

args[0]

) : args;

return f(xy[0])(xy[1]);

};

// MAIN ---

return main();

{{Out}}

<pre>simpleNumberRising{1..3}.txt ->

minusSignFlipsSequence 025.txt

minusSignFlipsSequence 030.txt

 

combined-{Q..P}{2..1}.txt ->

rangeless{random}string ->

rangeless{random}string</pre>

 

=={{header|Julia}}==

 

function ranged(str)

println(test, "->\n", [" " * x * "\n" for x in splatrange(test)]...)

end

<pre>

simpleNumberRising{1..3}.txt->

</pre>

 

{{trans|Wren}}

 

{{out}}

Note that, as usual, unicode output does not look good on a windows console for tests 6 & 7 (linux output shown)

stops after endpoint-08.txt

</pre>

=={{header|Python}}==

 

Here we use regular expressions for parsing and take an object orientated approach

to expansion of range expressions.

 

"""

 

# A negative step means we reverse the range.

start, stop = stop, start

 

elif start > stop:

cases = [

r"simpleNumberRising{1..3}.txt",

r"simpleAlphaDescending-{Z..X}.txt",

r"steppedDownAndPadded-{10..00..5}.txt",

r"minusSignFlipsSequence {030..20..-5}.txt",

r"combined-{Q..P}{2..1}.txt",

r"emoji{🌵..🌶}{🌽..🌾}etc",

r"li{teral",

r"rangeless{}empty",

r"steppedAlphaDescending-{Z..M..2}.txt",

r"reversedSteppedAlphaDescending-{Z..M..-2}.txt",

]

if __name__ == "__main__":

examples()

 

{{out}}

simpleNumberRising2.txt

simpleNumberRising3.txt

 

simpleAlphaDescending-{Z..X}.txt ->

minusSignFlipsSequence 025.txt

minusSignFlipsSequence 030.txt

 

combined-{Q..P}{2..1}.txt ->

li{teral ->

li{teral

 

rangeless{random}string ->

rangeless{random}string

 

 

steppedAlphaDescending-{Z..M..2}.txt ->

steppedAlphaDescending-P.txt

steppedAlphaDescending-N.txt

 

reversedSteppedAlphaDescending-{Z..M..-2}.txt ->

reversedSteppedAlphaDescending-Y.txt

</pre>

=={{header|Raku}}==

{{works with|Rakudo|2020.08.1}}

Also implements some of the string list functions described on the bash-hackers page.

 

my $list = rx/ ^ $<prefix> = .*? '{' (<-[,}]>+) +%% ',' '}' $<postfix> = .* $/;

 

say '';

}

{{out}}

<pre>simpleNumberRising{1..3}.txt ->

multi char emoji ranges fail {🌵🌵..🌵🌶}

</pre>

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var parseRange = Fn.new { |r|

asc = !asc

var t = n1

n2 = t

n3 = -n3

"steppedDownAndPadded-{10..00..5}.txt",

"minusSignFlipsSequence {030..20..-5}.txt",

"combined-{Q..P}{2..1}.txt",

"emoji{🌵..🌶}{🌽..🌾}etc",

"mixedNumberAlpha{5..k}",

"steppedAlphaRising{P..Z..2}.txt",

]

 

System.print(res.join("\n "))

System.print()

 

{{out}}

minusSignFlipsSequence 025.txt

minusSignFlipsSequence 030.txt

 

combined-{Q..P}{2..1}.txt ->

stops after endpoint-05.txt

stops after endpoint-08.txt

</pre>