github.com/jancarloviray/community@v0.41.1-0.20170124221257-33a66c87cf2f/app/public/codemirror/mode/livescript/index.html (about)

     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>