package main
import (
"constraints"
"fmt"
)
type Number interface {
constraints.Integer | constraints.Float
}
func Min[T constraints.Ordered](a, b T) T {
if a < b {
return a
}
return b
}
func Max[T constraints.Ordered](a, b T) T {
if a > b {
return a
}
return b
}
func Sum[T Number](values []T) T {
var sum T
for _, v := range values {
sum += v
}
return sum
}
func Map[T, R any](input []T, fn func(T) R) []R {
result := make([]R, len(input))
for i, v := range input {
result[i] = fn(v)
}
return result
}
func Filter[T any](input []T, predicate func(T) bool) []T {
result := make([]T, 0, len(input))
for _, v := range input {
if predicate(v) {
result = append(result, v)
}
}
return result
}
func Reduce[T, R any](input []T, initial R, fn func(R, T) R) R {
result := initial
for _, v := range input {
result = fn(result, v)
}
return result
}
type Stack[T any] struct {
items []T
}
func NewStack[T any]() *Stack[T] {
return &Stack[T]{items: make([]T, 0)}
}
func (s *Stack[T]) Push(item T) {
s.items = append(s.items, item)
}
func (s *Stack[T]) Pop() (T, bool) {
var zero T
if len(s.items) == 0 {
return zero, false
}
item := s.items[len(s.items)-1]
s.items = s.items[:len(s.items)-1]
return item, true
}
func (s *Stack[T]) Peek() (T, bool) {
var zero T
if len(s.items) == 0 {
return zero, false
}
return s.items[len(s.items)-1], true
}
func (s *Stack[T]) IsEmpty() bool {
return len(s.items) == 0
}
type Queue[T any] struct {
items []T
}
func NewQueue[T any]() *Queue[T] {
return &Queue[T]{items: make([]T, 0)}
}
func (q *Queue[T]) Enqueue(item T) {
q.items = append(q.items, item)
}
func (q *Queue[T]) Dequeue() (T, bool) {
var zero T
if len(q.items) == 0 {
return zero, false
}
item := q.items[0]
q.items = q.items[1:]
return item, true
}
type Result[T any] struct {
Value T
Error error
}
func (r Result[T]) IsSuccess() bool {
return r.Error == nil
}
type Option[T any] struct {
value T
present bool
}
func Some[T any](v T) Option[T] {
return Option[T]{value: v, present: true}
}
func None[T any]() Option[T] {
return Option[T]{present: false}
}
func (o Option[T]) IsPresent() bool {
return o.present
}
func (o Option[T]) Get() (T, bool) {
return o.value, o.present
}
type Comparable interface {
constraints.Ordered
}
type Set[T comparable] struct {
items map[T]struct{}
}
func NewSet[T comparable]() *Set[T] {
return &Set[T]{items: make(map[T]struct{})}
}
func (s *Set[T]) Add(item T) {
s.items[item] = struct{}{}
}
func (s *Set[T]) Contains(item T) bool {
_, ok := s.items[item]
return ok
}
func (s *Set[T]) Remove(item T) {
delete(s.items, item)
}
func (s *Set[T]) Size() int {
return len(s.items)
}
func main() {
nums := []int{1, 2, 3, 4, 5}
doubled := Map(nums, func(n int) int { return n * 2 })
evens := Filter(nums, func(n int) bool { return n%2 == 0 })
sum := Reduce(nums, 0, func(acc, n int) int { return acc + n })
fmt.Println("Doubled:", doubled)
fmt.Println("Evens:", evens)
fmt.Println("Sum:", sum)
}