README.md

   1 Moescript
   2 ==============
   3 Sharp and cute ><
   4
   5 Usage
   6 -----------------
   7
   8   1. `npm install moe`
   9   2. Enjoy
  10
  11 Features
  12 -----------------
  13 ### less braces. Use indent
  14
  15         def max(list):
  16                 var m = list[0]
  17                 for(i <- 0..list.length)
  18                         if(list[i] > m) m = list[i]
  19                 return m
  20
  21         // trace means "console.log" with last argument returned.
  22         trace max [5, 4, 3, 2, 1]
  23
  24 ### Literals: use []
  25         def emptyObject = [:]
  26         def gameConfig = [
  27                 player: [
  28                         name: "tom",
  29                         type: Human,
  30                         level: 1,
  31                         weapon: sword,
  32                         inventory: [food, food, potion, bomb]
  33                 ],
  34                 enemy: [
  35                         name: "Dragon",
  36                         type: Dragon,
  37                         level: 9
  38                 ]
  39         ]
  40
  41 ### Currying, and `def` wrappers
  42         def Y(g) =
  43                 // use "=" here...
  44                 def rec(x)(y) = g(x(x)) y
  45                 rec(rec) // ...means this value will be returned.
  46
  47         // Define recursive function using Y
  48         // fibonacci = Y(functon(recurse){return function(n){...}})
  49         def Y fibonacci(recurse)(n) =
  50                 if(n <= 2) 1
  51                 else recurse(n - 2) + recurse(n - 1)
  52
  53         fibonacci(5) // 5
  54
  55 ### Simple "class" definition
  56         def Man(name):
  57                 this.name = name
  58         def Man::speak(something):
  59                 trace something
  60
  61         def outof(Man) Child(name):
  62                 resend Man(name) // Man.call this, name
  63         def Child::speak(something):
  64                 trace "Ah!"
  65                 resend Man::speak(something) // Man.prototype.speak.call this, something
  66
  67         var tom = new Child "Tom"
  68         tom.speak "Thanks!"
  69
  70 ### Monadic transformation for async / enumerator / list comprehension......
  71 Asyncs
  72
  73         def asyncLib = require "moe/libs/async"
  74         def async = asyncLib.async
  75         def sleep = asyncLib.sleep // sleep(f, dt) === setTimrout(dt, f)
  76
  77         def f() = process wait loadResource(something)
  78         // def f = [build: fBuild]
  79         // where fBuild(schemata)()():
  80         //     return schemata.yield loadResource something, (resource) :>
  81         //         return schemata.return process resource
  82
  83         def async randPrintNums(n):
  84                 def tasks = []
  85                 for(i <- 0..n)
  86                         tasks.push async :>
  87                                 sleep! (100 * Math.random())
  88                                 trace index
  89                         where index = i
  90                 join! tasks
  91
  92         randPrintNums 100
  93
  94 Enumerators
  95
  96         def enumeration String::getEnumerator():
  97                 for(i <- 0..this.length)
  98                         enumeration.yield! this.charAt(i), i
  99
 100         for(c <- "this is a string")
 101                 trace c
 102
 103 List comprehension
 104
 105         -- Enumerator comprehension monad
 106         var ecSchemata = object defaultMonadSchemata, =>
 107                 def Enumerable @return(x):
 108                         if(x != undefined)
 109                                 enumeration.yield! x
 110                 def @bindYield(f, thisp, args) = f.apply thisp, arguments.slice(2)
 111                 def Enumerable @bind(list, callback):
 112                         for(x <- list)
 113                                 for(y <- callback x)
 114                                         enumeration.yield! y
 115
 116         var mktable(G) =
 117                 var f = G.build ecSchemata
 118                 f.apply(this, arguments)()
 119
 120         // simple usage
 121         for(item <- mktable {var x <- (1..100); x * 2 + 1}) trace item
 122
 123         // complicated usage
 124         var t = mktable {var x <- (1...9); var y <- (x...9); x + ' * ' + y + ' = ' + x * y }
 125         // t = mktable [build: fBuild]
 126         // where fBuild(schemata)()() =
 127         //     schemata.bind (1...9), (x) =>
 128         //         schemata.bind (x...9), (y) =>
 129         //             schemata.return (x + ' * ' + y + ' = ' + x * y)
 130         for(item <- t) trace item