Merge pull request #395 from amirhasanpour/generics

Update generics season

Author: ja7ad

content/chapter 6/6.2-generics fundamentals.md

@@ -24,15 +24,30 @@ weight: 11002
 
 **نمونه ساده:**
 
-```go
+{{< play >}}
+package main
+
+import (
+	"cmp"
+	"fmt"
+)
+
 // یک تابع ژنریک برای بازگرداندن بیشینه دو مقدار از هر نوع مرتب‌شونده
 func Max[T cmp.Ordered](a, b T) T {
-    if a > b {
-        return a
-    }
-    return b
+	if a > b {
+		return a
+	}
+	return b
 }
-```
+
+func main() {
+	res1 := Max(2, 3)
+	fmt.Println("Max is: ", res1)
+
+	res2 := Max(2.8, 3.1)
+	fmt.Println("Max is: ", res2)
+}
+{{< /play >}}
 
 اینجا `[T cmp.Ordered]` می‌گوید T می‌تواند هر نوعی باشد که قابلیت مقایسه داشته باشد (int، float64، string و ...).
 
@@ -54,11 +69,26 @@ func Max[T cmp.Ordered](a, b T) T {
 
 مثال:
 
-```go
+{{< play >}}
+package main
+
+import "fmt"
+
 func Print[T any](item T) {
-        fmt.Println(item)
-    }
-```
+	fmt.Println(item)
+}
+
+func main() {
+	strSlice := []string{"test1", "test2", "test3"}
+	intSlice := []int{1, 2, 3}
+
+	print("string slice: ")
+	Print(strSlice)
+
+	print("int slice: ")
+	Print(intSlice)
+}
+{{< /play >}}
 
 #### ۲. **Constraint (قید/محدودیت)**
 
@@ -67,12 +97,24 @@ func Print[T any](item T) {
 
 مثال:
 
- ```go
-     func Sum[T Number](a, b T) T { ... }
-    type Number interface {
-        int | int64 | float64
-    }
-```
+{{< play >}}
+package main
+
+import "fmt"
+
+func Sum[T Number](a, b T) T {
+	return a + b
+}
+
+type Number interface {
+	int | int64 | float64
+}
+
+func main() {
+	fmt.Println(Sum(2, 3))
+	fmt.Println(Sum(2.8, 3.1))
+}
+{{< /play >}}
 
 #### ۳. **Type Set (مجموعه نوع)**
 

content/chapter 6/6.3-generics syntax and structure.md

@@ -70,26 +70,56 @@ type Box[T any] struct {
 
 #### **مثال عملی – Stack ژنریک:**
 
-```go
+{{< play >}}
+package main
+
+import "fmt"
+
 type Stack[T any] struct {
-    items []T
+	items []T
 }
 
 func (s *Stack[T]) Push(item T) {
-    s.items = append(s.items, item)
+	s.items = append(s.items, item)
 }
 
 func (s *Stack[T]) Pop() (T, bool) {
-    if len(s.items) == 0 {
-        var zero T
-        return zero, false
-    }
-    idx := len(s.items) - 1
-    item := s.items[idx]
-    s.items = s.items[:idx]
-    return item, true
+	if len(s.items) == 0 {
+		var zero T
+		return zero, false
+	}
+	idx := len(s.items) - 1
+	item := s.items[idx]
+	s.items = s.items[:idx]
+	return item, true
 }
-```
+
+func main() {
+	intStack := Stack[int]{
+		items: []int{1, 2, 3},
+	}
+
+	fmt.Println("orginal int stack: ", intStack.items)
+	intStack.Push(4)
+	intStack.Push(5)
+	fmt.Println("int stack after push: ", intStack.items)
+	intStack.Pop()
+	fmt.Println("int stack after pop: ", intStack.items)
+
+	fmt.Println()
+
+	stringStack := Stack[string]{
+		items: []string{"test1", "test2", "test3"},
+	}
+
+	fmt.Println("orginal string stack: ", stringStack.items)
+	stringStack.Push("test4")
+	stringStack.Push("test5")
+	fmt.Println("string stack after push: ", stringStack.items)
+	stringStack.Pop()
+	fmt.Println("string stack after pop: ", stringStack.items)
+}
+{{< /play >}}
 
 این ساختار را می‌توانید برای `int`، `string`، struct دلخواه و ... به کار ببرید.
 

content/chapter 6/6.4-generics type sets and constraints.md

@@ -18,10 +18,20 @@ weight: 11004
 
 **مثال ساده:**
 
-```go
+{{< play >}}
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("int sum: ", Sum(2, 3))
+	fmt.Println("float sum", Sum(2.2, 3.4))
+}
+
 func Sum[T Number](a, b T) T { return a + b }
-type Number interface { int | float64 }
-```
+
+type Number interface{ int | float64 }
+{{< /play >}}
 
 در این مثال، فقط انواعی که در constraint Number تعریف شده‌اند، مجاز هستند.
 
@@ -33,29 +43,60 @@ type Number interface { int | float64 }
 
 #### **مثال: constraint مبتنی بر متد**
 
-```go
+{{< play >}}
+package main
+
+import "fmt"
+
+func main() {
+	person1 := person{
+		name: "sara",
+	}
+
+	PrintString(&person1)
+}
+
+type person struct {
+	name string
+}
+
+func (p *person) String() string {
+	str := fmt.Sprintf("person name is: %s", p.name)
+	return str
+}
+
 type Stringer interface {
-    String() string
+	String() string
 }
 
 func PrintString[T Stringer](v T) {
-    fmt.Println(v.String())
+	fmt.Println(v.String())
 }
-```
+{{< /play >}}
 
 هر نوعی که متد `String() string` را داشته باشد (مثلاً time.Time یا type خودتان)، می‌تواند برای این تابع استفاده شود.
 
 #### **مثال: constraint مبتنی بر type set (union)**
 
-```go
-type Numeric interface { int | int64 | float64 }
+{{< play >}}
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Max int is: ", Max(2, 7))
+	fmt.Println("Max float is: ", Max(2.9, 7.1))
+}
+
+type Numeric interface{ int | int64 | float64 }
+
 func Max[T Numeric](a, b T) T {
-    if a > b {
-        return a
-    }
-    return b
+	if a > b {
+		return a
+	}
+	return b
 }
-```
+{{< /play >}}
 
 فقط انواع عددی مجاز به استفاده از Max هستند.
 
@@ -91,31 +132,50 @@ Go چندین constraint از پیش تعریف‌شده دارد:
 
 - فقط نوع‌هایی که می‌توان با == یا != مقایسه کرد (برای map key یا مجموعه‌ها):
 
-    ```go
-    func Contains[T comparable](slice []T, v T) bool {
-        for _, item := range slice {
-            if item == v {
-                return true
-            }
-        }
-        return false
-    }
-    ```
+{{< play >}}
+package main
+
+import "fmt"
 
+func main() {
+	slice := []int{1, 2, 3, 4, 5, 6}
+	result := Contains(slice, 2)
+	fmt.Println(result)
+}
+
+func Contains[T comparable](slice []T, v T) bool {
+	for _, item := range slice {
+		if item == v {
+			return true
+		}
+	}
+	return false
+}
+{{< /play >}}
 
 #### **Ordered** (از پکیج cmp، Go 1.21+)
 
  برای انواعی که می‌توان از <, >, <=, >= استفاده کرد (int, float, string):
 
-  ```go
-    import "cmp"
-    func Min[T cmp.Ordered](a, b T) T {
-        if a < b {
-            return a
-        }
-        return b
-    }
-```
+{{< play >}}
+package main
+
+import (
+	"cmp"
+	"fmt"
+)
+
+func main() {
+	fmt.Println("Min is: ", Min(2, 7))
+}
+
+func Min[T cmp.Ordered](a, b T) T {
+	if a < b {
+		return a
+	}
+	return b
+}
+{{< /play >}}
 
 ## ۶.۴.۴ ساخت constraint سفارشی و ترکیبی (union constraints)