github.com/mattn/anko@v0.1.10/vm/example_functions_test.go (about)

     1  package vm_test
     2  
     3  import (
     4  	"fmt"
     5  	"log"
     6  
     7  	"github.com/mattn/anko/env"
     8  	"github.com/mattn/anko/vm"
     9  )
    10  
    11  func Example_vmFunctions() {
    12  	e := env.NewEnv()
    13  
    14  	err := e.Define("println", fmt.Println)
    15  	if err != nil {
    16  		log.Fatalf("define error: %v\n", err)
    17  	}
    18  
    19  	script := `
    20  func a(b) {
    21  	println(b)
    22  }
    23  a("b")
    24  
    25  a = func(b) {
    26  	println(b)
    27  }
    28  a("b")
    29  
    30  func(b) {
    31  	println(b)
    32  }("b")
    33  
    34  func a() {
    35  	return "a"
    36  }
    37  println(a())
    38  
    39  println("")
    40  
    41  
    42  func fib(n) {
    43  	if (n <= 1) {
    44  		return n
    45  	}
    46  	return fib(n - 1) + fib(n - 2) 
    47  }
    48  
    49  println(fib(8))
    50   
    51   func sum(n...) {
    52  	 t = 0
    53  	 for a in n {
    54  		 t += a
    55  	 }
    56  	 return t
    57   }
    58  println(sum(1, 2, 3, 4))
    59  
    60  func add(a, b) {
    61  	return a + b
    62  } 
    63  println(add([1, 2]...))
    64  `
    65  
    66  	_, err = vm.Execute(e, nil, script)
    67  	if err != nil {
    68  		log.Fatalf("execute error: %v\n", err)
    69  	}
    70  
    71  	// output:
    72  	// b
    73  	// b
    74  	// b
    75  	// a
    76  	//
    77  	// 21
    78  	// 10
    79  	// 3
    80  
    81  }
    82  
    83  func Example_vmFunctionsScope() {
    84  	e := env.NewEnv()
    85  
    86  	err := e.Define("println", fmt.Println)
    87  	if err != nil {
    88  		log.Fatalf("define error: %v\n", err)
    89  	}
    90  
    91  	script := `
    92  a = 1
    93  func () {
    94  	a = 2
    95  }()
    96  println(a)
    97  
    98  var a = 1
    99  func () {
   100  	a = 2
   101  }()
   102  println(a)
   103  
   104  a = 1
   105  func () {
   106  	var a = 2
   107  }()
   108  println(a)
   109  
   110  var a = 1
   111  func () {
   112  	var a = 2
   113  }()
   114  println(a)
   115  `
   116  
   117  	_, err = vm.Execute(e, nil, script)
   118  	if err != nil {
   119  		log.Fatalf("execute error: %v\n", err)
   120  	}
   121  
   122  	// output:
   123  	// 2
   124  	// 2
   125  	// 1
   126  	// 1
   127  
   128  }
   129  
   130  func testFunc1(a interface{}) int {
   131  	b, ok := a.([]interface{})
   132  	if ok {
   133  		return len(b)
   134  	}
   135  	return 0
   136  }
   137  
   138  func Example_vmFunctionsOutside() {
   139  
   140  	/*
   141  	   // the following function would be uncommented
   142  	   func testFunc1(a interface{}) int {
   143  	   	b, ok := a.([]interface{})
   144  	   	if ok {
   145  	   		return len(b)
   146  	   	}
   147  	   	return 0
   148  	   }
   149  	*/
   150  
   151  	e := env.NewEnv()
   152  
   153  	err := e.Define("println", fmt.Println)
   154  	if err != nil {
   155  		log.Fatalf("define error: %v\n", err)
   156  	}
   157  	err = e.Define("addString", func(a string, b string) string { return a + b })
   158  	if err != nil {
   159  		log.Fatalf("define error: %v\n", err)
   160  	}
   161  	// uses the function that would be declared above
   162  	err = e.Define("aFunc", testFunc1)
   163  	if err != nil {
   164  		log.Fatalf("define error: %v\n", err)
   165  	}
   166  
   167  	script := `
   168  a = addString("a", "b")
   169  println(a)
   170  
   171  a = aFunc([1, 2, 3])
   172  println(a) 
   173  `
   174  
   175  	_, err = vm.Execute(e, nil, script)
   176  	if err != nil {
   177  		log.Fatalf("execute error: %v\n", err)
   178  	}
   179  
   180  	// output:
   181  	// ab
   182  	// 3
   183  
   184  }