File modules/editor/codemirror/mode/livescript/index.html

Last commit: Sun Dec 17 01:14:09 2017 +0100	Jan Dankert	Integration eines weiteren Code-Editors: Codemirror. Demnächst müssen wir hier mal aufräumen und andere Editoren rauswerfen.


     1 <!doctype html>
     2 
     3 <title>CodeMirror: LiveScript mode</title>
     4 <meta charset="utf-8"/>
     5 <link rel=stylesheet href="../../doc/docs.css">
     6 
     7 <link rel="stylesheet" href="../../lib/codemirror.css">
     8 <link rel="stylesheet" href="../../theme/solarized.css">
     9 <script src="../../lib/codemirror.js"></script>
    10 <script src="livescript.js"></script>
    11 <style>.CodeMirror {font-size: 80%;border-top: 1px solid silver; border-bottom: 1px solid silver;}</style>
    12 <div id=nav>
    13   <a href="http://codemirror.net"><h1>CodeMirror</h1><img id=logo src="../../doc/logo.png"></a>
    14 
    15   <ul>
    16     <li><a href="../../index.html">Home</a>
    17     <li><a href="../../doc/manual.html">Manual</a>
    18     <li><a href="https://github.com/codemirror/codemirror">Code</a>
    19   </ul>
    20   <ul>
    21     <li><a href="../index.html">Language modes</a>
    22     <li><a class=active href="#">LiveScript</a>
    23   </ul>
    24 </div>
    25 
    26 <article>
    27 <h2>LiveScript mode</h2>
    28 <form><textarea id="code" name="code">
    29 # LiveScript mode for CodeMirror
    30 # The following script, prelude.ls, is used to
    31 # demonstrate LiveScript mode for CodeMirror.
    32 #   https://github.com/gkz/prelude-ls
    33 
    34 export objToFunc = objToFunc = (obj) ->
    35   (key) -> obj[key]
    36 
    37 export each = (f, xs) -->
    38   if typeof! xs is \Object
    39     for , x of xs then f x
    40   else
    41     for x in xs then f x
    42   xs
    43 
    44 export map = (f, xs) -->
    45   f = objToFunc f if typeof! f isnt \Function
    46   type = typeof! xs
    47   if type is \Object
    48     {[key, f x] for key, x of xs}
    49   else
    50     result = [f x for x in xs]
    51     if type is \String then result * '' else result
    52 
    53 export filter = (f, xs) -->
    54   f = objToFunc f if typeof! f isnt \Function
    55   type = typeof! xs
    56   if type is \Object
    57     {[key, x] for key, x of xs when f x}
    58   else
    59     result = [x for x in xs when f x]
    60     if type is \String then result * '' else result
    61 
    62 export reject = (f, xs) -->
    63   f = objToFunc f if typeof! f isnt \Function
    64   type = typeof! xs
    65   if type is \Object
    66     {[key, x] for key, x of xs when not f x}
    67   else
    68     result = [x for x in xs when not f x]
    69     if type is \String then result * '' else result
    70 
    71 export partition = (f, xs) -->
    72   f = objToFunc f if typeof! f isnt \Function
    73   type = typeof! xs
    74   if type is \Object
    75     passed = {}
    76     failed = {}
    77     for key, x of xs
    78       (if f x then passed else failed)[key] = x
    79   else
    80     passed = []
    81     failed = []
    82     for x in xs
    83       (if f x then passed else failed)push x
    84     if type is \String
    85       passed *= ''
    86       failed *= ''
    87   [passed, failed]
    88 
    89 export find = (f, xs) -->
    90   f = objToFunc f if typeof! f isnt \Function
    91   if typeof! xs is \Object
    92     for , x of xs when f x then return x
    93   else
    94     for x in xs when f x then return x
    95   void
    96 
    97 export head = export first = (xs) ->
    98   return void if not xs.length
    99   xs.0
   100 
   101 export tail = (xs) ->
   102   return void if not xs.length
   103   xs.slice 1
   104 
   105 export last = (xs) ->
   106   return void if not xs.length
   107   xs[*-1]
   108 
   109 export initial = (xs) ->
   110   return void if not xs.length
   111   xs.slice 0 xs.length - 1
   112 
   113 export empty = (xs) ->
   114   if typeof! xs is \Object
   115     for x of xs then return false
   116     return yes
   117   not xs.length
   118 
   119 export values = (obj) ->
   120   [x for , x of obj]
   121 
   122 export keys = (obj) ->
   123   [x for x of obj]
   124 
   125 export len = (xs) ->
   126   xs = values xs if typeof! xs is \Object
   127   xs.length
   128 
   129 export cons = (x, xs) -->
   130   if typeof! xs is \String then x + xs else [x] ++ xs
   131 
   132 export append = (xs, ys) -->
   133   if typeof! ys is \String then xs + ys else xs ++ ys
   134 
   135 export join = (sep, xs) -->
   136   xs = values xs if typeof! xs is \Object
   137   xs.join sep
   138 
   139 export reverse = (xs) ->
   140   if typeof! xs is \String
   141   then (xs / '')reverse! * ''
   142   else xs.slice!reverse!
   143 
   144 export fold = export foldl = (f, memo, xs) -->
   145   if typeof! xs is \Object
   146     for , x of xs then memo = f memo, x
   147   else
   148     for x in xs then memo = f memo, x
   149   memo
   150 
   151 export fold1 = export foldl1 = (f, xs) --> fold f, xs.0, xs.slice 1
   152 
   153 export foldr = (f, memo, xs) --> fold f, memo, xs.slice!reverse!
   154 
   155 export foldr1 = (f, xs) -->
   156   xs.=slice!reverse!
   157   fold f, xs.0, xs.slice 1
   158 
   159 export unfoldr = export unfold = (f, b) -->
   160   if (f b)?
   161     [that.0] ++ unfoldr f, that.1
   162   else
   163     []
   164 
   165 export andList = (xs) ->
   166   for x in xs when not x
   167     return false
   168   true
   169 
   170 export orList = (xs) ->
   171   for x in xs when x
   172     return true
   173   false
   174 
   175 export any = (f, xs) -->
   176   f = objToFunc f if typeof! f isnt \Function
   177   for x in xs when f x
   178     return yes
   179   no
   180 
   181 export all = (f, xs) -->
   182   f = objToFunc f if typeof! f isnt \Function
   183   for x in xs when not f x
   184     return no
   185   yes
   186 
   187 export unique = (xs) ->
   188   result = []
   189   if typeof! xs is \Object
   190     for , x of xs when x not in result then result.push x
   191   else
   192     for x   in xs when x not in result then result.push x
   193   if typeof! xs is \String then result * '' else result
   194 
   195 export sort = (xs) ->
   196   xs.concat!sort (x, y) ->
   197     | x > y =>  1
   198     | x < y => -1
   199     | _     =>  0
   200 
   201 export sortBy = (f, xs) -->
   202   return [] unless xs.length
   203   xs.concat!sort f
   204 
   205 export compare = (f, x, y) -->
   206   | (f x) > (f y) =>  1
   207   | (f x) < (f y) => -1
   208   | otherwise     =>  0
   209 
   210 export sum = (xs) ->
   211   result = 0
   212   if typeof! xs is \Object
   213     for , x of xs then result += x
   214   else
   215     for x   in xs then result += x
   216   result
   217 
   218 export product = (xs) ->
   219   result = 1
   220   if typeof! xs is \Object
   221     for , x of xs then result *= x
   222   else
   223     for x   in xs then result *= x
   224   result
   225 
   226 export mean = export average = (xs) -> (sum xs) / len xs
   227 
   228 export concat = (xss) -> fold append, [], xss
   229 
   230 export concatMap = (f, xs) --> fold ((memo, x) -> append memo, f x), [], xs
   231 
   232 export listToObj = (xs) ->
   233   {[x.0, x.1] for x in xs}
   234 
   235 export maximum = (xs) -> fold1 (>?), xs
   236 
   237 export minimum = (xs) -> fold1 (<?), xs
   238 
   239 export scan = export scanl = (f, memo, xs) -->
   240   last = memo
   241   if typeof! xs is \Object
   242   then [memo] ++ [last = f last, x for , x of xs]
   243   else [memo] ++ [last = f last, x for x in xs]
   244 
   245 export scan1 = export scanl1 = (f, xs) --> scan f, xs.0, xs.slice 1
   246 
   247 export scanr = (f, memo, xs) -->
   248   xs.=slice!reverse!
   249   scan f, memo, xs .reverse!
   250 
   251 export scanr1 = (f, xs) -->
   252   xs.=slice!reverse!
   253   scan f, xs.0, xs.slice 1 .reverse!
   254 
   255 export replicate = (n, x) -->
   256   result = []
   257   i = 0
   258   while i < n, ++i then result.push x
   259   result
   260 
   261 export take = (n, xs) -->
   262   | n <= 0
   263     if typeof! xs is \String then '' else []
   264   | not xs.length => xs
   265   | otherwise     => xs.slice 0, n
   266 
   267 export drop = (n, xs) -->
   268   | n <= 0        => xs
   269   | not xs.length => xs
   270   | otherwise     => xs.slice n
   271 
   272 export splitAt = (n, xs) --> [(take n, xs), (drop n, xs)]
   273 
   274 export takeWhile = (p, xs) -->
   275   return xs if not xs.length
   276   p = objToFunc p if typeof! p isnt \Function
   277   result = []
   278   for x in xs
   279     break if not p x
   280     result.push x
   281   if typeof! xs is \String then result * '' else result
   282 
   283 export dropWhile = (p, xs) -->
   284   return xs if not xs.length
   285   p = objToFunc p if typeof! p isnt \Function
   286   i = 0
   287   for x in xs
   288     break if not p x
   289     ++i
   290   drop i, xs
   291 
   292 export span = (p, xs) --> [(takeWhile p, xs), (dropWhile p, xs)]
   293 
   294 export breakIt = (p, xs) --> span (not) << p, xs
   295 
   296 export zip = (xs, ys) -->
   297   result = []
   298   for zs, i in [xs, ys]
   299     for z, j in zs
   300       result.push [] if i is 0
   301       result[j]?push z
   302   result
   303 
   304 export zipWith = (f,xs, ys) -->
   305   f = objToFunc f if typeof! f isnt \Function
   306   if not xs.length or not ys.length
   307     []
   308   else
   309     [f.apply this, zs for zs in zip.call this, xs, ys]
   310 
   311 export zipAll = (...xss) ->
   312   result = []
   313   for xs, i in xss
   314     for x, j in xs
   315       result.push [] if i is 0
   316       result[j]?push x
   317   result
   318 
   319 export zipAllWith = (f, ...xss) ->
   320   f = objToFunc f if typeof! f isnt \Function
   321   if not xss.0.length or not xss.1.length
   322     []
   323   else
   324     [f.apply this, xs for xs in zipAll.apply this, xss]
   325 
   326 export compose = (...funcs) ->
   327   ->
   328     args = arguments
   329     for f in funcs
   330       args = [f.apply this, args]
   331     args.0
   332 
   333 export curry = (f) ->
   334   curry$ f # using util method curry$ from livescript
   335 
   336 export id = (x) -> x
   337 
   338 export flip = (f, x, y) --> f y, x
   339 
   340 export fix = (f) ->
   341   ( (g, x) -> -> f(g g) ...arguments ) do
   342     (g, x) -> -> f(g g) ...arguments
   343 
   344 export lines = (str) ->
   345   return [] if not str.length
   346   str / \\n
   347 
   348 export unlines = (strs) -> strs * \\n
   349 
   350 export words = (str) ->
   351   return [] if not str.length
   352   str / /[ ]+/
   353 
   354 export unwords = (strs) -> strs * ' '
   355 
   356 export max = (>?)
   357 
   358 export min = (<?)
   359 
   360 export negate = (x) -> -x
   361 
   362 export abs = Math.abs
   363 
   364 export signum = (x) ->
   365   | x < 0     => -1
   366   | x > 0     =>  1
   367   | otherwise =>  0
   368 
   369 export quot = (x, y) --> ~~(x / y)
   370 
   371 export rem = (%)
   372 
   373 export div = (x, y) --> Math.floor x / y
   374 
   375 export mod = (%%)
   376 
   377 export recip = (1 /)
   378 
   379 export pi = Math.PI
   380 
   381 export tau = pi * 2
   382 
   383 export exp = Math.exp
   384 
   385 export sqrt = Math.sqrt
   386 
   387 # changed from log as log is a
   388 # common function for logging things
   389 export ln = Math.log
   390 
   391 export pow = (^)
   392 
   393 export sin = Math.sin
   394 
   395 export tan = Math.tan
   396 
   397 export cos = Math.cos
   398 
   399 export asin = Math.asin
   400 
   401 export acos = Math.acos
   402 
   403 export atan = Math.atan
   404 
   405 export atan2 = (x, y) --> Math.atan2 x, y
   406 
   407 # sinh
   408 # tanh
   409 # cosh
   410 # asinh
   411 # atanh
   412 # acosh
   413 
   414 export truncate = (x) -> ~~x
   415 
   416 export round = Math.round
   417 
   418 export ceiling = Math.ceil
   419 
   420 export floor = Math.floor
   421 
   422 export isItNaN = (x) -> x isnt x
   423 
   424 export even = (x) -> x % 2 == 0
   425 
   426 export odd = (x) -> x % 2 != 0
   427 
   428 export gcd = (x, y) -->
   429   x = Math.abs x
   430   y = Math.abs y
   431   until y is 0
   432     z = x % y
   433     x = y
   434     y = z
   435   x
   436 
   437 export lcm = (x, y) -->
   438   Math.abs Math.floor (x / (gcd x, y) * y)
   439 
   440 # meta
   441 export installPrelude = !(target) ->
   442   unless target.prelude?isInstalled
   443     target <<< out$ # using out$ generated by livescript
   444     target <<< target.prelude.isInstalled = true
   445 
   446 export prelude = out$
   447 </textarea></form>
   448     <script>
   449       var editor = CodeMirror.fromTextArea(document.getElementById("code"), {
   450         theme: "solarized light",
   451         lineNumbers: true
   452       });
   453     </script>
   454 
   455     <p><strong>MIME types defined:</strong> <code>text/x-livescript</code>.</p>
   456 
   457     <p>The LiveScript mode was written by Kenneth Bentley.</p>
   458 
   459   </article>



Download modules/editor/codemirror/mode/livescript/index.html


History
Sun, 17 Dec 2017 01:14:09 +0100	Jan Dankert	Integration eines weiteren Code-Editors: Codemirror. Demnächst müssen wir hier mal aufräumen und andere Editoren rauswerfen.