def foo(x): if x == 0 then 0 else "bar" end

let foo x = if x == 0 then 0 else "bar" end
foo :: int -> int | string

type IntString = X of int | Y of string

let x =
    match x with
    | :? Int as y -> print "is int"
    | :? String as y -> print "is string"

open Printf

let foo x = 
  if x = 0 then `MyInt 0 else `MyStr "bar"
  
  
let print = function
  | `MyInt x -> printf "`MyInt = %d\n" x
  | `MyStr x -> printf "`MyStr = %s\n" x
  | `MyFloat x -> printf "`MyStr = %f\n" x
  
let _ = print (foo 0)
let _ = print (foo 1)

foo :: int -> X int | Y string
let foo x = if x == 0 then X 0 else Y "bar" end

let x =
    match x with
    | :? Int as y -> print "is int"
    | :? String as y -> print "is string"

foo :: Int -> Either Int String
foo x = if x == 0 then Left 0 else Right "bar"

> either (+42) length $ foo 0
42
> either (+42) length $ foo 1
3

D>def foo(x): if x == 0 then 0 else "bar" end
D>

int f(int x);
void *f(void *x);

let foo x = if x == 0 then 0 else "hi" end
foo :: int -> int | string

let bar i = i + 1
let bar s = s + "\n"

let x1 = foo 0
x1 :: int | string

let x2 = foo 1
x2 :: int | string

//Магия:
let z1 = bar x1
z1 :: int | string

let z2 = bar x2
z2 :: int | string

A>Тогда уж и такой полиморфизм изобразить можно было бы :

A>let bar i = i + 1
A>let bar s = s + "\n"
A>//Магия:
A>let z1 = bar x1
A>z1 :: int | string
A>let z2 = bar x2
A>z2 :: int | string
A>

mapSum :: (a -> c) -> (b -> d) -> a | b -> c | d

z :: int | string -> int | string
z = mapSum (\i -> i + 1) (\s -> s + "\n")

D>>mapSum :: (a -> c) -> (b -> d) -> a | b -> c | d
D>>

(f `mapSum` g) `mapSum` h :: (a1 -> b1) -> (a2 -> b2) -> (a3 -> b3) -> (a1 | a2) | a3 -> (b1 | b2) | b3

f `mapSum` g `mapSum` h :: (a1 -> b1) -> (a2 -> b2) -> (a3 -> b3) -> a1 | a2 | a3 -> b1 | b2 | b3

\f g h -> f `mapSum` g `mapSum` h :: (a1 -> b1) -> (a2 -> b2) -> (a3 -> b3) -> a1 | a2 | a3 -> b1 | b2 | b3

class Plusable a where
  (+) :: a -> a -> b

instance Plusable Int where
  ...
instance Plusable String where
  ...

bar :: (Plusable a) => a -> a -> a
let bar (Plusable x) = x + x + x

let z1 = bar x1
z1 :: int | string

public static function exceptionProtect(f : Function, exnHandler : Function) : Function {
  return function(...args) : * {
    try {
      return f.applly(null, args);
    } catch (e : *) {
      exnHandler(e);
      throw e;
    }
  }
}

D>let foo x = if x == 0 then 0 else "bar" end
D>foo :: int -> int | string
D>

D>>let x =
D>>    match x with
D>>    | :? Int as y -> print "is int"
D>>    | :? String as y -> print "is string"
D>>

if (is_int($x)) {
   exit($x);
} else {
   // do something with string $x
}

void Foo(){DoSomething()}

void Foo() { try DoSomething catch }

Action GetWraper(Action x){
  return () => {try DoSomething catch}
}

foo x = if x == 0 then 0 else "bar"

bar x = if x == 0 then 42.42 else 'b'

M>public static function exceptionProtect(f : Function, exnHandler : Function) : Function {
M>  return function(...args) : * {
M>    try {
M>      return f.applly(null, args);
M>    } catch (e : *) {
M>      exnHandler(e);
M>      throw e;
M>    }
M>  }
M>}
M>

import std.traits;
import std.conv;
import std.stdio;


template ExceptionProtect(alias Fun, alias ExnHandler)
{
    ReturnType!Fun ExceptionProtect(ParameterTypeTuple!Fun args)
    {
    ReturnType!Fun Result;
    
    try{
        Result = Fun(args);
        }    
    catch(Exception e){
        ExnHandler(e);
        throw e;
        }
    
    return Result;
    }    
}


string TestInc(int i)
{
    if(i > 0)
        return text("Ok result = ", i + 1);
    else
        throw new Exception("TestInc() failed");
    
    return "Fail";
}


void TestExnHandler(Exception e)
{
    writeln("TestExnHandler run");
}

void main()
{
    writeln(ExceptionProtect!(TestInc, TestExnHandler)(123));
    writeln(ExceptionProtect!(TestInc, TestExnHandler)(-1));
}

const cls : Class = findClass(config.confClass);
const instance : Object = new Class();
const func = instance[config.confMethod];
return exceptoinProtect(func, protector);

function protectInterface(iface : Object, protector : Function) : Object {
  const res : Object = {};
  for (var item : String in iface) {
    var val : Object = iface[item];
    var valf : Function = val as Function;
    res[item] = valf != null ? exceptionProtect(valf, protector) : val;
  }  
  return res;
}

writeln(typeid(typeof(TestInc)));
writeln(typeid(typeof(ExceptionProtect!(TestInc, TestExnHandler))));

immutable(char)[]()
immutable(char)[]()

M>Вообще, вся эта магия нужна, когда присутствуют сразу оба типа варианта, описаных Василием. Есть функция, тип результата которой зависит от значения. Такая функция возникает, когда есть какая-либо внешная конфигурация "верхнего" уровня, не выраженная в коде. И при этом есть функции, тип которых зависит от типа аргументов, вроде приведенных выше. В статическом случае их можно реализовать шаблонами/макросами и т.п. Но вот применить их к результату функций первого типа не получится без динамики .

ВВ>>>>bar x = if x == 0 then 42.42 else 'b'
ВВ>>>>

foo x = if x == 0 then Left 0 else Right "bar"

case x of
     Left _ -> ...
     Right _ -> ...

let fun (x::xs) = fun' x xs 
                  where fun' a [] = \y -> y + a 
                        fun' a (x::xs) = \y -> fun' (y + a + x) xs

fun [1..3] 1 2 3 //saturation
fun [1..5] 1 2 3 4 5//saturation

let out x = write x $ out

function out (x) {
   write(x);
   return out;
}

ВВ>foo x = if x == 0 then Left 0 else Right "bar"

ВВ>case x of
ВВ>     Left _ -> ...
ВВ>     Right _ -> ...
ВВ>

let bar x =
    match x with
    | :? Int as y -> print "is int"
    | :? String as y -> print "is string"

bar Right x =
bar Left x =

D>let bar x =
D>    match x with
D>    | :? Int as y -> print "is int"
D>    | :? String as y -> print "is string"
D>

object foo(int x) {
  if (x == 0) return 0 else return "bar";
}

if (foo(0) is int) ...

D>bar Right x =
D>bar Left x =
D>

def tup = (0,1,2);

tup[3] //ошибка компиляции

def arr = array[0,1,2];

arr[3] //ошибка времени исполнения

data Either a b
= Left a
| Right b

case x of
     Left _ -> ...
     Right _ -> ...
     

data X = int|string

case x of
    _ :: int -> 
    _ :: string ->

type ret = Int of int | String of string

let foo x = if x = 0 then Int x else String "bar"

let test = function
  | Int x -> printf "%d\n" x
  | String s -> printf "%s\n" s

  let foo x = 
  if x = 0 then `MyInt 0 else `MyStr "bar"
  
  
let print = function
  | `MyInt x -> printf "`MyInt = %d\n" x
  | `MyStr1 x -> printf "`MyStr = %s\n" x
print foo 1

const f : Function = function(a : int, b : int = 3) : int {
  return a + b;
}
f(3);
f(5, 6);

const config : XML = loadConfig(xml);
const services : Function = parseServices(config);
const protectedService : Function = serviceProtect(services, callMethod(serivces, 'application', 'fatal-error'));
const someObject : FirstType = protectedService('get', 'some', 'strange', 'value');
const otherObject : SecondType = protectedService('convert', 'wrap-errors', someObject);
protectedService('call-service-expect-xml', 'service-name', 'operation-name', {fieldA : someObject.a, fieldB : otherObject.a}, {success : handleCallSuccess, await : waitCallHandler});
protectedService('show-dialog', 'about-dialog', protectedServices);
protectedService('show-dialog', 'format-drive-dialog', protectedServices, 'c:');

ВВ>let out x = write x $ out
ВВ>

ВВ>function out (x) {
ВВ>   write(x);
ВВ>   return out;
ВВ>}
ВВ>

  Out[T](x : T) : T // T -> T
  {
    Write(x);
    x
  }

VD>  Out[T](x : T) : T // T -> T
VD>  {
VD>    Write(x);
VD>    x
VD>  }
VD>

    def o(x)
    {
      Write(x);
      o
    }
    _ = o(1)(2)(3);

let foo x = if x==0 then 0 else "hi"
foo :: int -> int | string

let bar x = x + 1
bar :: int -> int
let bar x = x + "\n"
bar :: string -> string

let z1 = bar 1
z1 :: int
let z2 = bar "hi"
z2 :: string

bar :: (Num a) => a -> a
let bar x = x * x

let z1 = foo 0
let z2 = foo 1

z1 :: int
z2 :: string

let foo 0 = 0
let foo x {where x != 0} = "hi"

let f x y = foo x + foo y
f :: int -> int -> int|string

f :: a -> a
let f x = x
f :: a -> b -> b
let f x y = y

//Результат:
f :: a -> a|(b->b)

let myPrint fmt = \... -> printf fmt ...

H>>Компилятор же на это расскажет про циклический тип

\f -> (\x -> f (x x)) (\x -> f (x x))

let rec f x = f x $ rec f

rec writen "Line1" "Line2"

writen "Line1" $ writen "Line2"

ВВ>\f -> (\x -> f (x x)) (\x -> f (x x))
ВВ>

ВВ>let rec f x = f x $ rec f
ВВ>

ВВ>rec writen "Line1" "Line2"
ВВ>

ВВ>writen "Line1" $ writen "Line2"
ВВ>

writen("Line1\nLine2")

writen("Line1", "Line2")

writen("Line1");
writen("Line2");