cfe1302e82
use the term "pad" to add characters add ways to search for substrings read ints and floats
217 lines
No EOL
5.4 KiB
JavaScript
217 lines
No EOL
5.4 KiB
JavaScript
Elm.Native.String = {};
|
|
Elm.Native.String.make = function(elm) {
|
|
elm.Native = elm.Native || {};
|
|
elm.Native.String = elm.Native.String || {};
|
|
if (elm.Native.String.values) return elm.Native.String.values;
|
|
if ('values' in Elm.Native.String)
|
|
return elm.Native.String.values = Elm.Native.String.values;
|
|
|
|
var Char = Elm.Char.make(elm);
|
|
var Maybe = Elm.Maybe.make(elm);
|
|
var JS = Elm.JavaScript.make(elm);
|
|
var Tuple2 = Elm.Native.Utils.make(elm).Tuple2;
|
|
|
|
function isEmpty(str) {
|
|
return str.length === 0;
|
|
}
|
|
function cons(chr,str) {
|
|
return chr + str;
|
|
}
|
|
function uncons(str) {
|
|
var chr;
|
|
return (chr = str[0]) ? Maybe.Just(Tuple2(chr, str.slice(1)))
|
|
: Maybe.Nothing;
|
|
}
|
|
function length(str) {
|
|
return str.length;
|
|
}
|
|
function map(f,str) {
|
|
return str.split('').map(f).join('');
|
|
}
|
|
function filter(pred,str) {
|
|
return str.split('').filter(pred).join('');
|
|
}
|
|
function reverse(str) {
|
|
return str.split('').reverse().join('');
|
|
}
|
|
function foldl(f,b,str) {
|
|
var len = str.length;
|
|
for (var i = 0; i < len; ++i) {
|
|
b = A2(f, str[i], b);
|
|
}
|
|
return b;
|
|
}
|
|
function foldr(f,b,str) {
|
|
for (var i = str.length; i--; ) {
|
|
b = A2(f, str[i], b);
|
|
}
|
|
return b;
|
|
}
|
|
|
|
function split(sep, str) {
|
|
return str.split(sep);
|
|
}
|
|
function join(sep, strs) {
|
|
return JS.fromList(strs).join(sep);
|
|
}
|
|
function repeat(n, chr) {
|
|
var result = '';
|
|
while (n > 0) {
|
|
if (n & 1) result += chr;
|
|
n >>= 1, chr += chr;
|
|
}
|
|
return result;
|
|
}
|
|
function pad(n,chr,str) {
|
|
var half = n - str.length / 2;
|
|
return repeat(Math.ceil(half),chr) + str + repeat(half|0,chr);
|
|
}
|
|
function padRight(n,chr,str) {
|
|
return str + repeat(n - str.length, chr);
|
|
}
|
|
function padLeft(n,chr,str) {
|
|
return repeat(n - str.length, chr) + str;
|
|
}
|
|
|
|
function trim(str) {
|
|
return str.trim();
|
|
}
|
|
function trimLeft(str) {
|
|
return str.trimLeft();
|
|
}
|
|
function trimRight(str) {
|
|
return str.trimRight();
|
|
}
|
|
|
|
function words(str) {
|
|
return JS.toList(str.split(/\s+/g));
|
|
}
|
|
function unwords(str) {
|
|
return JS.fromList(str).join(' ');
|
|
}
|
|
function lines(str) {
|
|
return JS.toList(str.split(/\r\n|\r|\n/g));
|
|
}
|
|
function unlines(str) {
|
|
return JS.fromList(str).join('\n');
|
|
}
|
|
|
|
function toUpper(str) {
|
|
return str.toUpperCase();
|
|
}
|
|
function toLower(str) {
|
|
return str.toLowerCase();
|
|
}
|
|
|
|
function any(pred, str) {
|
|
for (var i = str.length; i--; ) {
|
|
if (pred(str[i])) return true;
|
|
}
|
|
return false;
|
|
}
|
|
function all(pred, str) {
|
|
for (var i = str.length; i--; ) {
|
|
if (!pred(str[i])) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function contains(sub, str) {
|
|
return str.indexOf(sub) > -1;
|
|
}
|
|
function startsWith(sub, str) {
|
|
return str.indexOf(sub) === 0;
|
|
}
|
|
function endsWith(sub, str) {
|
|
return str.lastIndexOf(sub) === str.length - sub.length;
|
|
}
|
|
function indexes(sub, str) {
|
|
var subLen = sub.length;
|
|
var i = 0;
|
|
var is = [];
|
|
while ((i = str.indexOf(sub, i)) > -1) {
|
|
is.push(i);
|
|
i = i + subLen;
|
|
}
|
|
return JS.toList(is);
|
|
}
|
|
|
|
function toInt(str) {
|
|
var s = JS.fromString(str);
|
|
var len = s.length;
|
|
if (len === 0) { return Maybe.Nothing; }
|
|
var start = 0;
|
|
if (s[0] == '-') {
|
|
if (len === 1) { return Maybe.Nothing; }
|
|
start = 1;
|
|
}
|
|
for (var i = start; i < len; ++i) {
|
|
if (!Char.isDigit(s[i])) { return Maybe.Nothing; }
|
|
}
|
|
return Maybe.Just(parseInt(s, 10));
|
|
}
|
|
|
|
function toFloat(str) {
|
|
var s = JS.fromString(str);
|
|
var len = s.length;
|
|
if (len === 0) { return Maybe.Nothing; }
|
|
var start = 0;
|
|
if (s[0] == '-') {
|
|
if (len === 1) { return Maybe.Nothing; }
|
|
start = 1;
|
|
}
|
|
var dotCount = 0;
|
|
for (var i = start; i < len; ++i) {
|
|
if (Char.isDigit(s[i])) { continue; }
|
|
if (s[i] === '.') {
|
|
dotCount += 1;
|
|
if (dotCount <= 1) { continue; }
|
|
}
|
|
return Maybe.Nothing;
|
|
}
|
|
return Maybe.Just(parseFloat(s));
|
|
}
|
|
|
|
return Elm.Native.String.values = {
|
|
isEmpty: isEmpty,
|
|
cons: F2(cons),
|
|
uncons: uncons,
|
|
length: length,
|
|
map: F2(map),
|
|
filter: F2(filter),
|
|
reverse: reverse,
|
|
foldl: F3(foldl),
|
|
foldr: F3(foldr),
|
|
|
|
split: F2(split),
|
|
join: F2(join),
|
|
repeat: F2(repeat),
|
|
|
|
pad: F3(pad),
|
|
padLeft: F3(padLeft),
|
|
padRight: F3(padRight),
|
|
|
|
trim: trim,
|
|
trimLeft: trimLeft,
|
|
trimRight: trimRight,
|
|
|
|
words: words,
|
|
unwords: unwords,
|
|
lines: lines,
|
|
unlines: unlines,
|
|
|
|
toUpper: toUpper,
|
|
toLower: toLower,
|
|
|
|
any: F2(any),
|
|
all: F2(all),
|
|
|
|
contains: F2(contains),
|
|
startsWith: F2(startsWith),
|
|
endsWith: F2(endsWith),
|
|
indexes: F2(indexes),
|
|
|
|
toInt: toInt,
|
|
toFloat: toFloat,
|
|
};
|
|
}; |