main = do
  putStrLn "Write a line: "
  line <- getLine
  putStrLn $ "Input was: " ++ line

-- impure
main = do
  putStrLn "Write a line: "
  line <- getLine
  putStrLn $ (append line)

-- pure
append :: String -> String
append input = "Input was: " ++ input

data Animal = Dog | Cat | Elk

data Animal =  Dog String 
             | Cat String
             | Elk String

name (Dog n) = n
name (Cat n) = n
name (Elk n) = n

Function<Animal, String> name = a -> a.name;

enum Animal {
   DOG("Max"), CAT("Nala"), ELK("Sam");
   String name;
   Animal(String name) { 
     this.name = name
   }
}

enum Animal { DOG, CAT, ELK }

data Animal = Dog String
            | Cat String Int
            | Elk Int String Double 
            | Unknown
            
info (Dog n) = "Dog: " ++ n
info (Cat n _) = "Cat: " ++ n
info (Elk _ n _) = "Elk: " ++ n
info _ = "Unknown animal"

enum Group { Mammal, Bird, Fish }

record Animal(String name, int age, Group group) {}

var elephant = new Animal("Elephant", 10, Mammal);

String name = elephant.name();
int age = elephant.age();
Type group = elephant.group();

data Group = Mammal | Bird | Fish deriving (Show)

data Animal = Animal {
   name :: String,
   age :: Int,
   group :: Group
}

elephant = (Animal "Elephant" 10 Mammal)
elephantName = name a
elephantAge = age a
elephantGroup = group a

data Person = Person {
   name :: String,
   adress :: String
}

data Country = Country { 
   name :: String 
}

toStr a = join "," [name a, adress a]

data Spec = Spec {
  engineType :: Engine,
  maxSpeed :: Speed,
  featureList :: [Feature]
}

data Automobile = 
  Car Spec | Bus Spec | Bike Spec

class Transport a where
  spec :: a -> Spec

instance Transport Automobile where
  spec (Car s) = s
  spec (Bus s) = s
  spec (Bike s) = s

record Spec(
  Engine engineType,
  Speed maxSpeed,
  List<Feature> featureList
) {}

interface Transport {
  Spec spec();
}

sealed interface Automobile extends Transport
    permits Car, Bus, Bike {}

final class Bus implement Automobile {
  public Bus(Spec spec) {
   this.spec = spec;
  }

  public Spec spec() {
   return spec;
  }
}

record Spec(
  Engine engineType,
  Speed maxSpeed,
  List<Feature> featureList
) {}

interface Transport {
  Spec spec();
}

sealed interface Automobile extends Transport
    permits Car, Bus, Bike, Any {}

non-sealed class Any implement Automobile {
  ...
}

// non-sealed:
// support specific extension points 
// while restricting others
// https://stackoverflow.com/a/63887136

inline class Point {
    private int x;
    private int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int x() { return x; }
    public int y() { return y; }
}

inline class Point {
    int x;
    int y;
}

class Line {
    Point x;
    Point y;
}

class Line {
    int x1;
    int y1;

    int x2;
    int y2;
}

public class MyClass {
  public int add(int x, int y){
     return x + y;
  }

  public String hello(){
     return "Hello, world!";
  }
}

import java.lang.*;

import java.util.Map;

import static 
   java.util.Arrays.sort;

public class MyClass {
  ...
}

import Prelude

import Data.Map
import qualified Data.Map as M

import Data.List (filter, sort)
import Data.List hiding (nub)

module MyClass where

module com.testmodule {
 requires module.name;
 exports mypackage.name;
}

module ChessGame (
  Result(..)
  easy,
  difficult,
  run) where

run level = play level
easy = (Chess Normal)
difficult = (Chess Strong)
data Result = Won | Lost | Draw
-----------------------------------
data Ai = Normal | Strong
data Chess = Chess Ai
class Game a where
  play :: a -> Result
instance Game Chess where
  play chessAi = ....

public interface Person<A> {
  String name(A a);
}

class Person a where
  name :: a -> String

class Person a where
   name :: a -> String

data Teacher = Teacher { tName :: String, tAge :: Int }
data Student = Student { sName :: String, sAge :: Int }

instance Person Teacher where
  name teacher = tName teacher
  age teacher = tAge teacher

instance Person Student where
  name student = sName student
  age student = sAge student

personAge :: Person p => p -> Int
personAge p = age p

main = do
    let 
      teacher  = (Teacher "Jane" 30)
      student = (Student "Peter" 30)
      teacherName = name teacher
      studentName = name student

  putStrLn $ "Age of " ++ teacherName ++ " " ++ (show $ personAge teacher)
  putStrLn $ "Age of " ++ studentName ++ " " ++ (show $ personAge teacher)

interface Person {
  String name();
}

class Student implements Person {
  String sName; int sAge;

  public Student(String sName, int sAge) {
    this.sName = sName;
    this.sAge = sAge;
  }

  @Override
  public String name() {
    return "Hello to " + this.sName;
  }
}

class Teacher implements Person {
  String tName; int tAge;

  public Teacher(String tName, int tAge) {
    this.tName = tName;
    this.tAge = tAge;
  }
  
  @Override
  public String name() {
    return "Hello to " + this.sName;
  }
}

class Main {
  public static void main(String[] args) {
    Teacher t = new Teacher("Jane", 30);
    System.out.println(t.name());

    Student s = new Student("Peter", 30);
    System.out.println(s.name());
  }
}

data Person = Person {
  salary :: Int,
  taxClass :: TaxClass
}

if (salary > 900)
 tax = salary * 0.44;
else
 tax = salary * 0.36;

if (salary > 900)
  return salary * 0.44;
else if (salary > 500)
  return salary * 0.36;
else 
  return salary * 0.24;

if salary > 900 
then salary * 0.44
else if salary > 500
     then salary * 0.36
     else salary * 0.24

if salary > 900 
then salary * 0.44
else if salary > 500
     then salary * 0.36
     else salary * 0.24

tax salary
  | salary > 900 = salary * 0.44
  | salary > 500 = salary * 0.36
  | otherwise = salary * 0.24

tax salary
  | salary > 900 = salary * 0.44
  | salary > 500 = salary * 0.36
  | otherwise = salary * 0.24

tax salary = salary * taxClass
  where taxClass
          | salary > 900 = 0.44
          | salary > 500 = 0.36
          | otherwise = 0.24

switch (taxClass) {
  case CLASS_1:
   return 0.44;
  case CLASS_2:
   return 0.36;
}

case taxClass of
  CLASS_1 -> 0.44
  CLASS_2 -> 0.36

switch (taxClass) {
  case CLASS_1:
   tax = 0.44;
   break;
  case CLASS_2:
   tax = 0.36;
   break;
}

switch (taxClass) {
  case CLASS_1 -> 0.44;
  case CLASS_2 -> 0.36;
}

case taxClass of
  CLASS_1 -> 0.44
  CLASS_2 -> 0.36

float clz = switch (taxClass) {
    case CLASS_1 -> 0.44;
    case CLASS_2 -> 0.36;
  }

enum Letter {A, B, C, D};
public String getLetter(Letter letter) {
  return switch (letter) {
    case A, B, C, D -> "A letter";
    default -> "Unknown";
  };
}

data Letter = A | B | C | D deriving (Enum, Eq) 
letter :: Letter -> String
letter letter 
  | elem letter [A .. D] = "A letter"
  | otherwise = "Unknown"

module com.testmodule {
 requires module.name;
 
 requires static module.name;
 requires transitive module.name;

 exports package.name;
 export package.name 
        to some.package;

 opens com.package;
 opens com.package 
       to another.module;
}