Spaces:
Running
Running
| <title>CodeMirror: LiveScript mode</title> | |
| <meta charset="utf-8"/> | |
| <link rel=stylesheet href="../../doc/docs.css"> | |
| <link rel="stylesheet" href="../../lib/codemirror.css"> | |
| <link rel="stylesheet" href="../../theme/solarized.css"> | |
| <script src="../../lib/codemirror.js"></script> | |
| <script src="livescript.js"></script> | |
| <style>.CodeMirror {font-size: 80%;border-top: 1px solid silver; border-bottom: 1px solid silver;}</style> | |
| <div id=nav> | |
| <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a> | |
| <ul> | |
| <li><a href="../../index.html">Home</a> | |
| <li><a href="../../doc/manual.html">Manual</a> | |
| <li><a href="https://github.com/codemirror/codemirror">Code</a> | |
| </ul> | |
| <ul> | |
| <li><a href="../index.html">Language modes</a> | |
| <li><a class=active href="#">LiveScript</a> | |
| </ul> | |
| </div> | |
| <article> | |
| <h2>LiveScript mode</h2> | |
| <form><textarea id="code" name="code"> | |
| # LiveScript mode for CodeMirror | |
| # The following script, prelude.ls, is used to | |
| # demonstrate LiveScript mode for CodeMirror. | |
| # https://github.com/gkz/prelude-ls | |
| export objToFunc = objToFunc = (obj) -> | |
| (key) -> obj[key] | |
| export each = (f, xs) --> | |
| if typeof! xs is \Object | |
| for , x of xs then f x | |
| else | |
| for x in xs then f x | |
| xs | |
| export map = (f, xs) --> | |
| f = objToFunc f if typeof! f isnt \Function | |
| type = typeof! xs | |
| if type is \Object | |
| {[key, f x] for key, x of xs} | |
| else | |
| result = [f x for x in xs] | |
| if type is \String then result * '' else result | |
| export filter = (f, xs) --> | |
| f = objToFunc f if typeof! f isnt \Function | |
| type = typeof! xs | |
| if type is \Object | |
| {[key, x] for key, x of xs when f x} | |
| else | |
| result = [x for x in xs when f x] | |
| if type is \String then result * '' else result | |
| export reject = (f, xs) --> | |
| f = objToFunc f if typeof! f isnt \Function | |
| type = typeof! xs | |
| if type is \Object | |
| {[key, x] for key, x of xs when not f x} | |
| else | |
| result = [x for x in xs when not f x] | |
| if type is \String then result * '' else result | |
| export partition = (f, xs) --> | |
| f = objToFunc f if typeof! f isnt \Function | |
| type = typeof! xs | |
| if type is \Object | |
| passed = {} | |
| failed = {} | |
| for key, x of xs | |
| (if f x then passed else failed)[key] = x | |
| else | |
| passed = [] | |
| failed = [] | |
| for x in xs | |
| (if f x then passed else failed)push x | |
| if type is \String | |
| passed *= '' | |
| failed *= '' | |
| [passed, failed] | |
| export find = (f, xs) --> | |
| f = objToFunc f if typeof! f isnt \Function | |
| if typeof! xs is \Object | |
| for , x of xs when f x then return x | |
| else | |
| for x in xs when f x then return x | |
| void | |
| export head = export first = (xs) -> | |
| return void if not xs.length | |
| xs.0 | |
| export tail = (xs) -> | |
| return void if not xs.length | |
| xs.slice 1 | |
| export last = (xs) -> | |
| return void if not xs.length | |
| xs[*-1] | |
| export initial = (xs) -> | |
| return void if not xs.length | |
| xs.slice 0 xs.length - 1 | |
| export empty = (xs) -> | |
| if typeof! xs is \Object | |
| for x of xs then return false | |
| return yes | |
| not xs.length | |
| export values = (obj) -> | |
| [x for , x of obj] | |
| export keys = (obj) -> | |
| [x for x of obj] | |
| export len = (xs) -> | |
| xs = values xs if typeof! xs is \Object | |
| xs.length | |
| export cons = (x, xs) --> | |
| if typeof! xs is \String then x + xs else [x] ++ xs | |
| export append = (xs, ys) --> | |
| if typeof! ys is \String then xs + ys else xs ++ ys | |
| export join = (sep, xs) --> | |
| xs = values xs if typeof! xs is \Object | |
| xs.join sep | |
| export reverse = (xs) -> | |
| if typeof! xs is \String | |
| then (xs / '')reverse! * '' | |
| else xs.slice!reverse! | |
| export fold = export foldl = (f, memo, xs) --> | |
| if typeof! xs is \Object | |
| for , x of xs then memo = f memo, x | |
| else | |
| for x in xs then memo = f memo, x | |
| memo | |
| export fold1 = export foldl1 = (f, xs) --> fold f, xs.0, xs.slice 1 | |
| export foldr = (f, memo, xs) --> fold f, memo, xs.slice!reverse! | |
| export foldr1 = (f, xs) --> | |
| xs.=slice!reverse! | |
| fold f, xs.0, xs.slice 1 | |
| export unfoldr = export unfold = (f, b) --> | |
| if (f b)? | |
| [that.0] ++ unfoldr f, that.1 | |
| else | |
| [] | |
| export andList = (xs) -> | |
| for x in xs when not x | |
| return false | |
| true | |
| export orList = (xs) -> | |
| for x in xs when x | |
| return true | |
| false | |
| export any = (f, xs) --> | |
| f = objToFunc f if typeof! f isnt \Function | |
| for x in xs when f x | |
| return yes | |
| no | |
| export all = (f, xs) --> | |
| f = objToFunc f if typeof! f isnt \Function | |
| for x in xs when not f x | |
| return no | |
| yes | |
| export unique = (xs) -> | |
| result = [] | |
| if typeof! xs is \Object | |
| for , x of xs when x not in result then result.push x | |
| else | |
| for x in xs when x not in result then result.push x | |
| if typeof! xs is \String then result * '' else result | |
| export sort = (xs) -> | |
| xs.concat!sort (x, y) -> | |
| | x > y => 1 | |
| | x < y => -1 | |
| | _ => 0 | |
| export sortBy = (f, xs) --> | |
| return [] unless xs.length | |
| xs.concat!sort f | |
| export compare = (f, x, y) --> | |
| | (f x) > (f y) => 1 | |
| | (f x) < (f y) => -1 | |
| | otherwise => 0 | |
| export sum = (xs) -> | |
| result = 0 | |
| if typeof! xs is \Object | |
| for , x of xs then result += x | |
| else | |
| for x in xs then result += x | |
| result | |
| export product = (xs) -> | |
| result = 1 | |
| if typeof! xs is \Object | |
| for , x of xs then result *= x | |
| else | |
| for x in xs then result *= x | |
| result | |
| export mean = export average = (xs) -> (sum xs) / len xs | |
| export concat = (xss) -> fold append, [], xss | |
| export concatMap = (f, xs) --> fold ((memo, x) -> append memo, f x), [], xs | |
| export listToObj = (xs) -> | |
| {[x.0, x.1] for x in xs} | |
| export maximum = (xs) -> fold1 (>?), xs | |
| export minimum = (xs) -> fold1 (<?), xs | |
| export scan = export scanl = (f, memo, xs) --> | |
| last = memo | |
| if typeof! xs is \Object | |
| then [memo] ++ [last = f last, x for , x of xs] | |
| else [memo] ++ [last = f last, x for x in xs] | |
| export scan1 = export scanl1 = (f, xs) --> scan f, xs.0, xs.slice 1 | |
| export scanr = (f, memo, xs) --> | |
| xs.=slice!reverse! | |
| scan f, memo, xs .reverse! | |
| export scanr1 = (f, xs) --> | |
| xs.=slice!reverse! | |
| scan f, xs.0, xs.slice 1 .reverse! | |
| export replicate = (n, x) --> | |
| result = [] | |
| i = 0 | |
| while i < n, ++i then result.push x | |
| result | |
| export take = (n, xs) --> | |
| | n <= 0 | |
| if typeof! xs is \String then '' else [] | |
| | not xs.length => xs | |
| | otherwise => xs.slice 0, n | |
| export drop = (n, xs) --> | |
| | n <= 0 => xs | |
| | not xs.length => xs | |
| | otherwise => xs.slice n | |
| export splitAt = (n, xs) --> [(take n, xs), (drop n, xs)] | |
| export takeWhile = (p, xs) --> | |
| return xs if not xs.length | |
| p = objToFunc p if typeof! p isnt \Function | |
| result = [] | |
| for x in xs | |
| break if not p x | |
| result.push x | |
| if typeof! xs is \String then result * '' else result | |
| export dropWhile = (p, xs) --> | |
| return xs if not xs.length | |
| p = objToFunc p if typeof! p isnt \Function | |
| i = 0 | |
| for x in xs | |
| break if not p x | |
| ++i | |
| drop i, xs | |
| export span = (p, xs) --> [(takeWhile p, xs), (dropWhile p, xs)] | |
| export breakIt = (p, xs) --> span (not) << p, xs | |
| export zip = (xs, ys) --> | |
| result = [] | |
| for zs, i in [xs, ys] | |
| for z, j in zs | |
| result.push [] if i is 0 | |
| result[j]?push z | |
| result | |
| export zipWith = (f,xs, ys) --> | |
| f = objToFunc f if typeof! f isnt \Function | |
| if not xs.length or not ys.length | |
| [] | |
| else | |
| [f.apply this, zs for zs in zip.call this, xs, ys] | |
| export zipAll = (...xss) -> | |
| result = [] | |
| for xs, i in xss | |
| for x, j in xs | |
| result.push [] if i is 0 | |
| result[j]?push x | |
| result | |
| export zipAllWith = (f, ...xss) -> | |
| f = objToFunc f if typeof! f isnt \Function | |
| if not xss.0.length or not xss.1.length | |
| [] | |
| else | |
| [f.apply this, xs for xs in zipAll.apply this, xss] | |
| export compose = (...funcs) -> | |
| -> | |
| args = arguments | |
| for f in funcs | |
| args = [f.apply this, args] | |
| args.0 | |
| export curry = (f) -> | |
| curry$ f # using util method curry$ from livescript | |
| export id = (x) -> x | |
| export flip = (f, x, y) --> f y, x | |
| export fix = (f) -> | |
| ( (g, x) -> -> f(g g) ...arguments ) do | |
| (g, x) -> -> f(g g) ...arguments | |
| export lines = (str) -> | |
| return [] if not str.length | |
| str / \\n | |
| export unlines = (strs) -> strs * \\n | |
| export words = (str) -> | |
| return [] if not str.length | |
| str / /[ ]+/ | |
| export unwords = (strs) -> strs * ' ' | |
| export max = (>?) | |
| export min = (<?) | |
| export negate = (x) -> -x | |
| export abs = Math.abs | |
| export signum = (x) -> | |
| | x < 0 => -1 | |
| | x > 0 => 1 | |
| | otherwise => 0 | |
| export quot = (x, y) --> ~~(x / y) | |
| export rem = (%) | |
| export div = (x, y) --> Math.floor x / y | |
| export mod = (%%) | |
| export recip = (1 /) | |
| export pi = Math.PI | |
| export tau = pi * 2 | |
| export exp = Math.exp | |
| export sqrt = Math.sqrt | |
| # changed from log as log is a | |
| # common function for logging things | |
| export ln = Math.log | |
| export pow = (^) | |
| export sin = Math.sin | |
| export tan = Math.tan | |
| export cos = Math.cos | |
| export asin = Math.asin | |
| export acos = Math.acos | |
| export atan = Math.atan | |
| export atan2 = (x, y) --> Math.atan2 x, y | |
| # sinh | |
| # tanh | |
| # cosh | |
| # asinh | |
| # atanh | |
| # acosh | |
| export truncate = (x) -> ~~x | |
| export round = Math.round | |
| export ceiling = Math.ceil | |
| export floor = Math.floor | |
| export isItNaN = (x) -> x isnt x | |
| export even = (x) -> x % 2 == 0 | |
| export odd = (x) -> x % 2 != 0 | |
| export gcd = (x, y) --> | |
| x = Math.abs x | |
| y = Math.abs y | |
| until y is 0 | |
| z = x % y | |
| x = y | |
| y = z | |
| x | |
| export lcm = (x, y) --> | |
| Math.abs Math.floor (x / (gcd x, y) * y) | |
| # meta | |
| export installPrelude = !(target) -> | |
| unless target.prelude?isInstalled | |
| target <<< out$ # using out$ generated by livescript | |
| target <<< target.prelude.isInstalled = true | |
| export prelude = out$ | |
| </textarea></form> | |
| <script> | |
| var editor = CodeMirror.fromTextArea(document.getElementById("code"), { | |
| theme: "solarized light", | |
| lineNumbers: true | |
| }); | |
| </script> | |
| <p><strong>MIME types defined:</strong> <code>text/x-livescript</code>.</p> | |
| <p>The LiveScript mode was written by Kenneth Bentley.</p> | |
| </article> | |