lachezar

{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE QuasiQuotes      #-}

module Lib
  ( run
  ) where

import           Text.Regex.PCRE.Heavy

newtype Word' =

lachezar

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module Main where

newtype USD = USD Int deriving (Show, Num)
newtype EUR = EUR Int deriving (Show, Num)

main :: IO ()
main = do
  print $ (USD 12) + (USD 11)

lachezar

sealed trait Currency
case object Dollar extends Currency
case object Euro extends Currency

case class Money[T <: Currency](value: Int, currency: T) {
  def +(that: Money[T]): Money[T] = {
    Money[T](this.value + that.value, currency)
  }
}

lachezar

package org.example;

import java.util.Optional;
import java.util.Random;
import java.util.function.Supplier;

class NPEChecked extends Exception implements Supplier<NPEChecked> {
  private static final NPEChecked instance = new NPEChecked();

  @Override

lachezar

case class IO[A](unsafeRun: () => A):

  def map[B](f: A => B): IO[B] =
    IO(() => f(unsafeRun()))

  def flatMap[B](f: A => IO[B]): IO[B] =
    IO(() => f(unsafeRun()).unsafeRun())

val io: IO[Int] = IO(() => {
  println("Running side effect!!!")

lachezar

trait Monad[M[_]] {
  def pure[A](a: A): M[A]
  def flatMap[A, B](m: M[A])(f: A => M[B]): M[B]
}

enum MyOption[+T]:
  case None
  case Some(value: T)

given Monad[MyOption] with