kmizu

object ImplicitParams {
  trait C[A]
}                                                                                                                               

kmizu

(1 to 10).foreach{x =>
  (1 to 10).foreach{y =>
    print(x * y+ "\t")
  }
  println()
}

kmizu

trait M[T] {
  implicit val m: Manifest[T]
}

case class Point(x: Int, y: Int)                                                                    

object Main extends M[Point] {
  implicit lazy val m: Manifest[Point] = manifest[Point]
  def main(args: Array[String]) {
    m

kmizu

use std::fmt;
use List::{Cons, Nil};

enum List<T> {
  Cons(T, Box<List<T>>),
  Nil
}

impl<T> fmt::Display for List<T> where T : fmt::Display {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

kmizu

use std::fmt;
use List::{Cons, Nil};

enum List<T> {
  Cons(T, Box<List<T>>),
  Nil
}

impl<T> fmt::Display for List<T> where T : fmt::Display {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

kmizu

use std::fmt;
use List::{Cons, Nil};
use std::sync::Arc;

enum List<T> {
  Cons(T, Arc<List<T>>),
  Nil
}

impl<T> fmt::Display for List<T> where T : fmt::Display {

kmizu

use std::fmt;
use List::{Cons, Nil};
use std::sync::Arc;
 
enum List<T> {
  Cons(T, Arc<List<T>>),
  Nil
}
 
impl<T> fmt::Display for List<T> where T : fmt::Display {

kmizu

use std::fmt;
use List::{Cons, Nil};
use std::sync::Arc;
 
enum List<T> {
  Cons(T, Arc<List<T>>),
  Nil
}
 
impl<T> fmt::Display for List<T> where T : fmt::Display {

kmizu

use std::fmt;
use List::{Cons, Nil};
use std::sync::Arc;
 
#[derive(PartialEq, Clone)]
enum List<T> {
  Cons(T, Arc<List<T>>),
  Nil
}
 

kmizu

use std::fmt;
use List::{Cons, Nil};
use std::sync::Arc;
 
#[derive(PartialEq, Clone)]
enum List<T> {
  Cons(T, Arc<List<T>>),
  Nil
}