github.com/mattn/anko@v0.1.10/vm/example_containers_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_vmArrays() {
    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  a = []interface{1, 2}
    21  println(a)
    22  
    23  a += 3
    24  println(a)
    25  
    26  a = []interface{}
    27  // this automatically appends to array
    28  a[0] = 1
    29  println(a)
    30  
    31  println("")
    32  
    33  a = []interface{}
    34  // this would give an index out of range error
    35  // a[1] = 1
    36  
    37  a = []interface{1, 2}
    38  b = []interface{3, 4}
    39  c = a + b
    40  println(c)
    41  
    42  c = []interface{1, 2} + []interface{3, 4}
    43  println(c)
    44  
    45  println("")
    46  
    47  c = []interface{a} + b
    48  println(c)
    49  
    50  c = []interface{a} + []interface{b}
    51  println(c)
    52  
    53  c = []interface{[]interface{1, 2}} + []interface{[]interface{3, 4}}
    54  println(c)
    55  
    56  println("")
    57  
    58  a = []interface{1, 2}
    59  
    60  println(len(a))
    61  
    62  println(a[1])
    63  
    64  a = [1, 2]
    65  println(a)
    66  `
    67  
    68  	_, err = vm.Execute(e, nil, script)
    69  	if err != nil {
    70  		log.Fatalf("execute error: %v\n", err)
    71  	}
    72  
    73  	// output:
    74  	// [1 2]
    75  	// [1 2 3]
    76  	// [1]
    77  	//
    78  	// [1 2 3 4]
    79  	// [1 2 3 4]
    80  	//
    81  	// [[1 2] 3 4]
    82  	// [[1 2] [3 4]]
    83  	// [[1 2] [3 4]]
    84  	//
    85  	// 2
    86  	// 2
    87  	// [1 2]
    88  }
    89  
    90  func Example_vmMaps() {
    91  	e := env.NewEnv()
    92  
    93  	err := e.Define("println", fmt.Println)
    94  	if err != nil {
    95  		log.Fatalf("define error: %v\n", err)
    96  	}
    97  
    98  	script := `
    99  a = map[interface]interface{}
   100  println(a)
   101  
   102  a.b = 1
   103  println(a)
   104  println(a.b)
   105  
   106  a["b"] = 2
   107  println(a["b"])
   108  
   109  println(len(a))
   110  
   111  println("")
   112  
   113  b, ok = a["b"]
   114  println(b)
   115  println(ok)
   116  
   117  delete(a, "b")
   118  
   119  _, ok = a["b"]
   120  println(ok)
   121  
   122  println("")
   123  
   124  a = {}
   125  println(a)
   126  
   127  a.b = 1
   128  println(a)
   129  println(a.b)
   130  
   131  a["b"] = 2
   132  println(a["b"])
   133  
   134  `
   135  
   136  	_, err = vm.Execute(e, nil, script)
   137  	if err != nil {
   138  		log.Fatalf("execute error: %v\n", err)
   139  	}
   140  
   141  	// output:
   142  	// map[]
   143  	// map[b:1]
   144  	// 1
   145  	// 2
   146  	// 1
   147  	//
   148  	// 2
   149  	// true
   150  	// false
   151  	//
   152  	// map[]
   153  	// map[b:1]
   154  	// 1
   155  	// 2
   156  }
   157  
   158  func Example_vmStructs() {
   159  	e := env.NewEnv()
   160  
   161  	err := e.Define("println", fmt.Println)
   162  	if err != nil {
   163  		log.Fatalf("define error: %v\n", err)
   164  	}
   165  
   166  	script := `
   167  a = make(struct {
   168  	A int64,
   169  	B float64
   170  })
   171  println(a)
   172  
   173  a.A = 1
   174  println(a)
   175  println(a.A)
   176  
   177  a.B = 2.5
   178  println(a)
   179  println(a.B)
   180  `
   181  
   182  	_, err = vm.Execute(e, nil, script)
   183  	if err != nil {
   184  		log.Fatalf("execute error: %v\n", err)
   185  	}
   186  
   187  	// output:
   188  	// {0 0}
   189  	// {1 0}
   190  	// 1
   191  	// {1 2.5}
   192  	// 2.5
   193  }
   194  
   195  func Example_vmModules() {
   196  
   197  	e := env.NewEnv()
   198  
   199  	err := e.Define("println", fmt.Println)
   200  	if err != nil {
   201  		log.Fatalf("define error: %v\n", err)
   202  	}
   203  
   204  	script := `
   205  module rectangle {
   206  	_length = 1
   207  	_width = 1
   208  
   209  	func setLength (length) {
   210  		if length <= 0 {
   211  			return
   212  		}
   213  		_length = length
   214  	}
   215  
   216  	func setWidth (width) {
   217  		if width <= 0 {
   218  			return
   219  		}
   220  		_width = width
   221  	}
   222  
   223  	func area () {
   224  		return _length * _width
   225  	}
   226  
   227  	func perimeter () {
   228  		return 2 * (_length + _width)
   229  	}
   230   }
   231  
   232  rectangle1 = rectangle
   233  
   234  rectangle1.setLength(4)
   235  rectangle1.setWidth(5)
   236  
   237  println(rectangle1.area())
   238  println(rectangle1.perimeter())
   239  
   240  rectangle2 = rectangle
   241  
   242  rectangle2.setLength(2)
   243  rectangle2.setWidth(4)
   244  
   245  println(rectangle2.area())
   246  println(rectangle2.perimeter())
   247  `
   248  
   249  	_, err = vm.Execute(e, nil, script)
   250  	if err != nil {
   251  		log.Fatalf("execute error: %v\n", err)
   252  	}
   253  
   254  	// output:
   255  	// 20
   256  	// 18
   257  	// 8
   258  	// 12
   259  }