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 ->

rangeless{random}string</pre>

 

<br><br>

 

=={{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|Raku}}==

{{works with|Rakudo|2020.08.1}}

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

 

 

sub expand (Str $string) {

quietly my ($start, $end, $incr) = $/<start end incr>».Str;

$incr ||= 1;

$incr.=abs;

 

$sl = $start.chars if $start.starts-with('0');

$el = $end.chars if $end.starts-with('0');

}

}

}

}

if ($prefix ~ $postfix).chars {

@return = $these.map: { $string.subst($list, $prefix ~ $_ ~ $postfix) } if $these.elems > 1

@return = $these.join: ' '

}

}

@return

# Test some other features

 

 

 

> -> $test {

say "$test ->";

say '';

{{out}}

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

rangeless{random}string

 

 

stops after endpoint-{02..10..3}.txt ->

stops after endpoint-08.txt

 

 

 

 

</pre>