csharp.cs

using System;

namespace foo {
    class Program {
        static Expr myExpr =
            new Add(
                new Mul(
                    new CInt(3),
                    new CInt(2)
                ),
                new Div(
                    new CInt(20),
                    new CInt(5)
                )
            );


        static int Calc(Expr expr) => expr switch {
            CInt(var i) => i,
            Add(var l, var r) => Calc(l) + Calc(r),
            Sub(var l, var r) => Calc(l) - Calc(r),
            Mul(var l, var r) => Calc(l) *  Calc(r),
            Div(var l, var r) => Calc(l) / Calc(r),
            _ => throw new InvalidProgramException()
        };

        static void Main(string[] args) {
            Console.WriteLine(myExpr);
            Console.WriteLine(Calc(myExpr));
        }
    }

// ************************************ Expr の定義 *****************************************
    class Expr {}
    class CInt : Expr {
        public int Value { get; }
        public CInt(int value) => Value = value;
        public void Deconstruct(out int value) => value = Value;
        public override string ToString() => $"CInt({Value})";
    }

    class Add : Expr {
        public Expr Left { get; }
        public Expr Right{ get; }
        public Add(Expr l, Expr r) => (Left,Right) = (l, r);
        public void Deconstruct(out Expr l, out Expr r) => (l, r) = (Left, Right);
        public override string ToString() => $"Add({Left}, {Right})";
    }
    class Sub : Expr {
        public Expr Left { get; }
        public Expr Right{ get; }
        public Sub(Expr l, Expr r) => (Left,Right) = (l, r);
        public void Deconstruct(out Expr l, out Expr r) => (l, r) = (Left, Right);
        public override string ToString() => $"Sub({Left}, {Right})";
      }
    class Mul : Expr {
        public Expr Left { get; }
        public Expr Right{ get; }
        public Mul(Expr l, Expr r) => (Left,Right) = (l, r);
        public void Deconstruct(out Expr l, out Expr r) => (l, r) = (Left, Right);
        public override string ToString() => $"Mul({Left}, {Right})";
     }
    class Div : Expr {
        public Expr Left { get; }
        public Expr Right{ get; }
        public Div(Expr l, Expr r) => (Left,Right) = (l, r);
        public void Deconstruct(out Expr l, out Expr r) => (l, r) = (Left, Right);
        public override string ToString() => $"Div({Left}, {Right})";
     }
}

haskell.hs

module Main where

data Expr =
    CInt Int
    | Add Expr Expr
    | Sub Expr Expr
    | Mul Expr Expr
    | Div Expr Expr
    deriving Show

expr :: Expr
expr =
    Add
        (Mul
            (CInt 2)
            (CInt 3))
        (Div
            (CInt 20)
            (CInt 5))


calc :: Expr -> Int
calc (CInt i) = i
calc (Add l r) = calc l + calc r
calc (Sub l r) = calc l - calc r
calc (Mul l r) = calc l * calc r
calc (Div l r) = calc l `div` calc r

main :: IO ()
main =  do
    print expr
    print $ calc expr

ocaml.ml

type expr =
    | CInt of int
    | Add of expr * expr
    | Sub of expr * expr
    | Mul of expr * expr
    | Div of expr * expr
    [@@deriving show]

let myExpr =
    Add (
        Mul (
            (CInt 2),
            (CInt 3)),
        Div (
            (CInt 20),
            (CInt 5)))

let rec calc = function
    | CInt i -> i
    | Add (e1, e2) -> calc e1 + calc e2
    | Sub (e1, e2) -> calc e1 - calc e2
    | Mul (e1, e2) -> calc e1 * calc e2
    | Div (e1, e2) -> calc e1 / calc e2

let () =
    print_string (show_expr myExpr);
    print_newline ();
    print_int (calc myExpr);
    print_newline ()

scala.scala

sealed abstract class Expr
case class CInt(value: Int) extends Expr
case class Add(left: Expr, right: Expr) extends Expr
case class Sub(left: Expr, right: Expr) extends Expr
case class Mul(left: Expr, right: Expr) extends Expr
case class Div(left: Expr, right: Expr) extends Expr


object Main {
    def myExpr: Expr =
        Add(
            Mul(
                CInt(3),
                CInt(2)),
            Div(
                CInt(20),
                CInt(5)))

    def calc(expr: Expr): Int = expr match {
        case CInt(n) => n
        case Add(l, r) => calc(l) + calc(r)
        case Sub(l, r) => calc(l) - calc(r)
        case Mul(l, r) => calc(l) * calc(r)
        case Div(l, r) => calc(l) / calc(r)
    }

    def main(args: Array[String]): Unit = {
        println(myExpr)
        println(calc(myExpr))
    }
}