 out as it was not overpowered by spices, says Sujoy Gupta, Executive Chef, Umaid Bhawan Palace.
Wash and clean the fish (bekti, mahi mahi, sole or basa will work well). Cut each fillet into 3 large pieces. Place the yogurt in a large bowl. Add to it the ginger paste, garlic paste, green chilli paste, fresh coriander leaves paste, lemon juice, ghee, garam masala and salt. Mix well. Marinate the fish pieces in this spicy masala and set aside for 2 hours. Now prepare a charcoal fire. Place the fish pieces in between the jali and roast on slow charcoal fire, turning the jali from time to time till the fish pieces are well roasted and cooked on both sides. Serve hot.
Slit the red chillies, discard the seeds and soak in water for 15 minutes. Take out the juice of the lemon and set aside. Heat ghee in a kadai. When hot, add in the mutton pieces with salt. Cook till the mutton absorbs its juices completely and the ghee remains. Pour in some water. Bring it to a boil, then simmer and cook till the meat is tender and the water has dried up. Now add the red chillies and cook for 5–7 minutes. Always add the red chillies just 10 minutes before taking the meat off the flame. Adjust seasonings. Serve hot.
Chakki ka saag is an unusual recipe, made from ingredients easily available in one’s kitchen. This recipe calls for kneading the dough and keeping it aside for a minimum of two hours, then rinsing it under running water, till all the husk has disappeared, and you have clean and clear water flowing over the dough. A kilogram of whole-wheat atta would yield 200 gm of the dough, which is then cut into small cubes and is lightly blended with red chilli powder, turmeric powder and salt. This is fried in a little oil and added to the yogurt based gravy that has onion as the base and a medley of flavours from the dry spices, ginger and garlic that have been cooked over slow flame.
In a large bowl, place the whole wheat flour. Add water as required to form a stiff dough. Set this dough aside for one hour. Now place the stiff dough into a round strainer, one that we use for straining dry whole wheat flour. Place the strainer in a parat, pour a little water on the dough and keep kneading. And keep pouring water and kneading the dough until it becomes sponge-like. Now add in the salt, garam masala powder, red chilli powder to the spongy dough and knead well. Make small cubes of chakki. Heat oil in a kadai. When hot, put in a few pieces of chakki at a time and deep fry them till cooked. A kilo of whole wheat flour will get you about 250 gms of chakki.
with coriander leaves. Serve hot.
Three-year-old girl dies after falling into container of mid-day meal...
Due to mid-day meal workers' protest, schools to be deprived of meals...<gh_stars>10-100
Collection of Scala Macro goodies ([BSD-licensed](./LICENSE))


- *[Streams](https://github.com/nativelibs4java/scalaxy-streams)* (*MIGRATED TO ITS OWN REPO*) provide a macro and a compiler plugin that optimize streamed collection operations / for comprehensions by rewriting them to equivalent while loops (Scala 2.11.x):

    ```scala
    for (i <- 0 to n;
         ii = i * i;
         j <- i to n;
         jj = j * j;
         if (ii - jj) % 2 == 0;
         k <- (i + j) to n)
      yield { (ii, jj, k) }
    ```

- *[Loops](https://github.com/nativelibs4java/Scalaxy/tree/master/Loops)* provide a macro that optimizes simple foreach loops on Ranges by rewriting them to equivalent while loops (Scala 2.10.x):

    ```scala
    import scalaxy.loops._
    
    for (i <- 0 until 100000000 optimized) {... }
    ```
    (special case of / superseeded by Streams below)

- *[JSON](https://github.com/nativelibs4java/Scalaxy/tree/master/JSON)* ([ScalaDoc](http://ochafik.github.io/Scalaxy/JSON/latest/api/index.html)) provides macro-based `json` string interpolation with smart error reporting, compile-time renormalization, deconstruction and more.

- *[Parano](https://github.com/nativelibs4java/scalaxy-parano)* (*MIGRATED TO ITS OWN REPO*) provides compile-time checks to avoid common naming mistakes (ambiguous or swapped case class field extractor names, ambiguous unnamed param names with same type...)

- *[Privacy](https://github.com/nativelibs4java/Scalaxy/tree/master/Privacy)* changes the default member visibily from public to private (unless the `@public` annotation is used)

- *[Beans](https://github.com/nativelibs4java/Scalaxy/tree/master/Beans)* ([ScalaDoc](http://ochafik.github.io/Scalaxy/Beans/latest/api/index.html)) are a nifty combination of Dynamics and macros that provide a type-safe eye-candy syntax to set fields of regular Java Beans in a Scala way (without any runtime dependency at all!):

    ```scala
    import scalaxy.beans._
    
    new MyBean().set(foo = 10, bar = 12)
    ```

- *[Fx](https://github.com/nativelibs4java/Scalaxy/tree/master/Fx)* ([ScalaDoc](http://ochafik.github.io/Scalaxy/Fx/latest/api/index.html)) contains an experimental JavaFX DSL (with no runtime dependency) that makes it easy to build objects and define event handlers:

    ```scala
    new Button().set(
      text = bind {
        s"Hello, ${textField.getText}"
      },
      onAction = {
        println("Hello World!")
      }
    )
    ```

- *[Reified](https://github.com/nativelibs4java/scalaxy-reified)*  (*MIGRATED TO ITS OWN REPO*) provides a powerful reified values mechanism that deals well with composition and captures of runtime values, allowing for complex ASTs to be generated during runtime for re-compilation or transformation purposes. It preserves the original value that was reified, allowing for flexible mixed usage of runtime value and compile-time AST.

    ```scala
    import scalaxy.reified._
    
    def comp(capture1: Int): ReifiedFunction1[Int, Int] = {
      val capture2 = Seq(10, 20, 30)
      val f = reified((x: Int) => capture1 + capture2(x))
      val g = reified((x: Int) => x * x)
      
      g.compose(f)
    }
    
    println("AST: " + comp(10).expr.tree)
    ```

- Obsolete experiments (mostly because of quasiquotes):

  - *[MacroExtensions](https://github.com/nativelibs4java/Scalaxy/tree/master/Obsolete/MacroExtensions)* provides an extremely simple (and *experimental*) syntax to define extensions methods as macros:

      ```scala
      @scalaxy.extension[Any] 
      def quoted(quote: String): String = 
        quote + self + quote
        
      @scalaxy.extension[Int] 
      def copiesOf[T : ClassTag](generator: => T): Array[T] = 
        Array.fill[T](self)(generator)
    
     ...
      println(10.quoted("'"))
      // macro-expanded to `"'" + 10 + "'"`
      
      println(3 copiesOf new Entity)
      // macro-expanded to `Array.fill(3)(new Entity)`
      ```

  - *[Compilets](https://github.com/nativelibs4java/Scalaxy/tree/master/Obsolete/Compilets)* provide an easy way to express AST rewrites, backed by a compiler plugin and an sbt plugin.

  - *[Debug](https://github.com/nativelibs4java/Scalaxy/tree/master/Debug)* ([ScalaDoc](http://ochafik.github.io/Scalaxy/Debug/latest/api/index.html)) provides `assert`, `require` and `assume` macros that automatically add a useful message to the regular [Predef](http://www.scala-lang.org/api/current/index.html#scala.Predef$) calls.
    Please prefer [