カテゴリー: イベント

fn main() {
    // case1 : borrow in "String":mutable case
    //
    let mut aa = String::from("abc");       // variable length "String"
    let bb = &mut aa;
    bb.push_str("gh");
    let cc = format!("{}{}", "ko", bb);    // Linking "Strings"
    println!("mutable case (bb, cc) : {}, {}", bb, cc);

    //aa += "refa";     // error ; second mutable borrow occurs here, after first borrow you can't change the original content
    *bb += "refb";      // you can't use `+=` on type `&mut String`, use reference return
    println!("updated bb : {}", bb);

    // case2 : immutable case
    //
    let aa_i = String::from("kile");
    let bb_i1 = &aa_i;
    let bb_i2 = &aa_i;
    println!("immutable case (bb_i1, bb_i2) : {}, {}", bb_i1, bb_i2);

    // case3 :  literal(immutable) case in "str"
    //
    let aa_c = "abc";
    let bb_c = aa_c;    // refrence in immutable case, you can eliminate "&"
    //bb_c.push_str("gh");  // "push_str" is not found in `&&str` since bb_c is immutable
    let cc_c = format!("{}{}", "ko", bb_c); // linked output is a "String"
    println!("bb_c, cc_c : {}, {}", bb_c, cc_c);

    // case4 : reference return
    //
    let original = String::from("def");
    let reference = &original;
    if original == *reference {        // comparing "String == &String" causes compile error, if "*" is not used
        println!("equal");
    } else {
        println!("not equal");
    }
}

package main

import "fmt"

func add(i int) func() int {
	n := i

	clo := func() int {
		n++
		return n
	}

	return clo		// equivalent to specify anonymous function here and maybe it's more popular
}

func main() {
	a := add(1)
	for i := 1; i < 10; i++ {
		fmt.Println(a())
	}
}

fn f1(i: i32) -> Box<dyn FnMut -> i32> {	// FnMut recieves &mut self
	let mut i = i;						// dyn keyword sepcifies a trait pointer in the heap area
	Box::new(move || {				// force to allocate values in the heap area
		i += 1;
		i
	})
 }
 
 fn main() {
	 let mut cup = f1(0);
	 for _ in 1..10 {
		 println!("{}", cup());
	 }
 }

// safety
type WeekDay = 'Mon' | 'Tue' | 'Wed' | 'Thu' | 'Fri'
type Day = WeekDay | 'Sat' | 'Sun'

function getNextDay(w: Day): Day | undefined{
    switch (w){
        case 'Mon': return 'Tue'
        case 'Thu': return 'Wed'
        case 'Wed': return 'Thu'
        case 'Thu': return 'Fri'
        case 'Fri': return 'Sat'
        case 'Sat': return 'Sun'
        case 'Sun': return "Mon"
    }
    return undefined
}

console.log(getNextDay('Mon'))

function getNextDay(w) {
    switch (w) {
        case 'Mon': return 'Tue';
        case 'Thu': return 'Wed';
        case 'Wed': return 'Thu';
        case 'Thu': return 'Fri';
        case 'Fri': return 'Sat';
        case 'Sat': return 'Sun';
        case 'Sun': return "Mon";
    }
    return undefined;
}
console.log(getNextDay('Mon'));

package main

import (
	"fmt"
)

func main() {
    lightOne := new(Incandescent) 	// only change these lines if new lighting is introduced
    lightTwo := new(LedLight)		//

    myRoom := NewRoom(lightOne, lightTwo) // DI or object Injection

    myRoom.SwitchOnOne()
    myRoom.SwitchOnTwo()
}

type LightSocket interface {
    LightUp() string
}

// room has two sokets
type Room struct {
    LightOne LightSocket		// prepare only socket, not bulb
    LightTwo LightSocket
}

// define switch on method of the two sockets
func (r *Room) SwitchOnOne() {
    fmt.Println("1番照明:", r.LightOne.LightUp())
}
func (r *Room) SwitchOnTwo() {
    fmt.Println("2番照明:", r.LightTwo.LightUp())
}

// Constructor Injection
func NewRoom(lightOne, lightTwo LightSocket) *Room {
    room := &Room{
        LightOne: lightOne,
        LightTwo: lightTwo,
    }
    return room
}

// Led light
type LedLight struct{}

func (*LedLight) LightUp() string {
    return "LEDが光るよ!"
}

// Filament bulb
type Incandescent struct{}

func (*Incandescent) LightUp() string {
    return "フィラメントが光るよ!"
}