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

enum Animal {
   DOG("Max"), CAT("Nala"),
   ELK("Sam");

   String name;
   Animal(String name) { 
     this.name = name
   }
}

data Animal = Dog | Cat | Elk

enum Animal {
   DOG, CAT, ELK
}

data Animal =  Dog String 
             | Cat String
             | Elk String

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

enum AnimalType { Mammal, Bird, Fish }

record Animal(String name, int age, AnimalType type) {}

@Test
void propertiesEquals() {
  var elephant = new Animal("Elephant", 10, Mammal);

  assertEquals(elephant.name(), "Elephant");
  assertEquals(elephant.age(), 10);
  assertEquals(elephant.type(), Mammal);
}

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

data Animal = Animal {
   name :: String,
   age :: Int,
   type :: AnimalType
}

instance Show Animal where
  show (Animal a b c) = a ++ "," ++ show c

main = do
  print $ (Animal "Elephant" 10 Mammal)
  putStrLn $ name (Animal "Elephant" 10 Mammal)
  
 -- Output: Elephant,Mammal
 -- Output: Elephant

sealed interface Node
    permits A, B, C { ... }

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

data Transport = Car Spec 
       | Bus Spec | Plane Spec

class Automobile a where
  spec :: a -> Spec

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

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; }
}

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;
 
 requires static module.name;
 requires transitive module.name;

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

 opens com.package;
 opens com.package to anotherModule;
}

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

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;
}

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 ..] = "A letter"
  | otherwise = "Unknown"