cfe1302 · elk · git.iko.soy

git.iko.soy/elk

on master help sign in

Add and rename functions

cfe1302Evan Czaplicki13 years ago

libraries/Native/Basics.js−41

compare with master

unifiedsplit

@@ -6,9 +6,7 @@ Elm.Native.Basics.make = function(elm) {

6 if (elm.Native.Basics.values) return elm.Native.Basics.values;

8 var JS = Elm.Native.JavaScript.make(elm);

9− // var Maybe = Elm.Maybe(elm);

10 var Utils = Elm.Native.Utils.make(elm);

9 var Utils = Elm.Native.Utils.make(elm);

11− //var Char = Elm.Char(elm);

13 function div(a,b) { return (a/b)|0; }

11 function div(a,b) { return (a/b)|0; }

14 function rem(a,b) { return a % b; }

12 function rem(a,b) { return a % b; }

@@ -28,43 +26,7 @@ Elm.Native.Basics.make = function(elm) {

28 function uncurry(f,v) { return A2(f,v._0,v._1); }

26 function uncurry(f,v) { return A2(f,v._0,v._1); }

29 function fst(t) { return t._0; }

27 function fst(t) { return t._0; }

30 function snd(t) { return t._1; }

28 function snd(t) { return t._1; }

31−/*

32− function readInt(str) {

33− var s = JS.fromString(str);

34− var len = s.length;

35− if (len === 0) { return Maybe.Nothing; }

36− var start = 0;

37− if (s[0] == '-') {

38− if (len === 1) { return Maybe.Nothing; }

39− start = 1;

40− }

41− for (var i = start; i < len; ++i) {

42− if (!Char.isDigit(s[i])) { return Maybe.Nothing; }

43− }

44− return Maybe.Just(parseInt(s, 10));

45− }

47− function readFloat(str) {

48− var s = JS.fromString(str);

49− var len = s.length;

50− if (len === 0) { return Maybe.Nothing; }

51− var start = 0;

52− if (s[0] == '-') {

53− if (len === 1) { return Maybe.Nothing; }

54− start = 1;

55− }

56− var dotCount = 0;

57− for (var i = start; i < len; ++i) {

58− if (Char.isDigit(s[i])) { continue; }

59− if (s[i] === '.') {

60− dotCount += 1;

61− if (dotCount <= 1) { continue; }

62− }

63− return Maybe.Nothing;

64− }

65− return Maybe.Just(parseFloat(s));

66− }

67−*/

68 var basics = {

30 var basics = {

69 div:F2(div),

31 div:F2(div),

70 rem:F2(rem),

32 rem:F2(rem),

@@ -97,9 +59,6 @@ Elm.Native.Basics.make = function(elm) {

97 round:Math.round,

59 round:Math.round,

98 toFloat:function(x) { return x; },

60 toFloat:function(x) { return x; },

100− //readInt:readInt,

101− //readFloat:readFloat,

102−

103 curry:F3(curry),

62 curry:F3(curry),

104 uncurry:F2(uncurry),

63 uncurry:F2(uncurry),

105 fst:fst,

64 fst:fst,

libraries/Native/String.js+73−7

@@ -6,6 +6,7 @@ Elm.Native.String.make = function(elm) {

6 if ('values' in Elm.Native.String)

7 return elm.Native.String.values = Elm.Native.String.values;

9+ var Char = Elm.Char.make(elm);

9 var Maybe = Elm.Maybe.make(elm);

10 var Maybe = Elm.Maybe.make(elm);

10 var JS = Elm.JavaScript.make(elm);

11 var JS = Elm.JavaScript.make(elm);

11 var Tuple2 = Elm.Native.Utils.make(elm).Tuple2;

12 var Tuple2 = Elm.Native.Utils.make(elm).Tuple2;

@@ -61,14 +62,14 @@ Elm.Native.String.make = function(elm) {

61 }

62 }

62 return result;

63 return result;

63 }

64 }

64− function center(n,chr,str) {

65+ function pad(n,chr,str) {

65 var half = n - str.length / 2;

66 var half = n - str.length / 2;

66 return repeat(Math.ceil(half),chr) + str + repeat(half|0,chr);

67 return repeat(Math.ceil(half),chr) + str + repeat(half|0,chr);

67 }

68 }

68− function justifyLeft(n,chr,str) {

69+ function padRight(n,chr,str) {

69 return str + repeat(n - str.length, chr);

70 return str + repeat(n - str.length, chr);

70 }

71 }

71− function justifyRight(n,chr,str) {

72+ function padLeft(n,chr,str) {

72 return repeat(n - str.length, chr) + str;

73 return repeat(n - str.length, chr) + str;

73 }

74 }

@@ -115,6 +116,62 @@ Elm.Native.String.make = function(elm) {

115 return true;

116 return true;

116 }

117 }

117

118

119+ function contains(sub, str) {

120+ return str.indexOf(sub) > -1;

121+ }

122+ function startsWith(sub, str) {

123+ return str.indexOf(sub) === 0;

124+ }

125+ function endsWith(sub, str) {

126+ return str.lastIndexOf(sub) === str.length - sub.length;

127+ }

128+ function indexes(sub, str) {

129+ var subLen = sub.length;

130+ var i = 0;

131+ var is = [];

132+ while ((i = str.indexOf(sub, i)) > -1) {

133+ is.push(i);

134+ i = i + subLen;

135+ }

136+ return JS.toList(is);

137+ }

138+

139+ function toInt(str) {

140+ var s = JS.fromString(str);

141+ var len = s.length;

142+ if (len === 0) { return Maybe.Nothing; }

143+ var start = 0;

144+ if (s[0] == '-') {

145+ if (len === 1) { return Maybe.Nothing; }

146+ start = 1;

147+ }

148+ for (var i = start; i < len; ++i) {

149+ if (!Char.isDigit(s[i])) { return Maybe.Nothing; }

150+ }

151+ return Maybe.Just(parseInt(s, 10));

152+ }

153+

154+ function toFloat(str) {

155+ var s = JS.fromString(str);

156+ var len = s.length;

157+ if (len === 0) { return Maybe.Nothing; }

158+ var start = 0;

159+ if (s[0] == '-') {

160+ if (len === 1) { return Maybe.Nothing; }

161+ start = 1;

162+ }

163+ var dotCount = 0;

164+ for (var i = start; i < len; ++i) {

165+ if (Char.isDigit(s[i])) { continue; }

166+ if (s[i] === '.') {

167+ dotCount += 1;

168+ if (dotCount <= 1) { continue; }

169+ }

170+ return Maybe.Nothing;

171+ }

172+ return Maybe.Just(parseFloat(s));

173+ }

174+

118 return Elm.Native.String.values = {

175 return Elm.Native.String.values = {

119 isEmpty: isEmpty,

176 isEmpty: isEmpty,

120 cons: F2(cons),

177 cons: F2(cons),

@@ -129,9 +186,10 @@ Elm.Native.String.make = function(elm) {

129 split: F2(split),

186 split: F2(split),

130 join: F2(join),

187 join: F2(join),

131 repeat: F2(repeat),

188 repeat: F2(repeat),

132− center: F3(center),

189+

133− justifyLeft: F3(justifyLeft),

190+ pad: F3(pad),

134− justifyRight: F3(justifyRight),

191+ padLeft: F3(padLeft),

192+ padRight: F3(padRight),

135

193

136 trim: trim,

194 trim: trim,

137 trimLeft: trimLeft,

195 trimLeft: trimLeft,

@@ -146,6 +204,14 @@ Elm.Native.String.make = function(elm) {

146 toLower: toLower,

204 toLower: toLower,

147

205

148 any: F2(any),

206 any: F2(any),

149− all: F2(all)

207+ all: F2(all),

208+

209+ contains: F2(contains),

210+ startsWith: F2(startsWith),

211+ endsWith: F2(endsWith),

212+ indexes: F2(indexes),

213+

214+ toInt: toInt,

215+ toFloat: toFloat,

150 };

216 };

151};

217};

libraries/String.elm+35

@@ -134,3 +134,38 @@ any = Native.String.any

134-}

135all : (Char -> Bool) -> String -> Bool

136all = Native.String.all

137+

138+{-|

139+-}

140+contains : String -> String -> Bool

141+contains = Native.String.contains

142+

143+{-|

144+-}

145+startsWith : String -> String -> Bool

146+startsWith = Native.String.startsWith

147+

148+{-|

149+-}

150+endsWith : String -> String -> Bool

151+endsWith = Native.String.endsWith

152+

153+{-|

154+-}

155+indices : String -> String -> [Int]

156+indices = Native.String.indexes

157+

158+{-|

159+-}

160+indexes : String -> String -> [Int]

161+indexes = Native.String.indexes

162+

163+{-|

164+-}

165+toInt : String -> Maybe Int

166+toInt = Native.String.toInt

167+

168+{-|

169+-}

170+toFloat : String -> Maybe Float

171+toFloat = Native.String.toFloat