| |
 | Posted by bearophile
in reply to Stretto |  Permalink Reply |
|
bearophile 
Posted in reply to Stretto
| Stretto:
> F# now has Discriminated Unions:
>
> http://msdn.microsoft.com/en-US/library/dd233226.aspx
>
> Would it be possible to have something similar in D?
Unless I am missing something, they seem the regular algebraic types you find in Haskell, etc.
A little example program in Haskell (from https://github.com/Dobiasd/articles/blob/master/from_oop_to_fp_-_inheritance_and_the_expression_problem.md ):
import Data.List
data Base = Foo Int | Bar String
step :: Base -> Int -> Base
-- Add delta to internal state.
step (Foo intVal) delta = Foo $ intVal + delta
-- Concat delta as string to internal state.
step (Bar strVal) delta = Bar $ strVal ++ show delta
display :: Base -> String
display (Foo intVal) = show intVal
display (Bar strVal) = strVal
-- Steps every object in l by 1.
stepAll :: [Base] -> [Base]
stepAll l = map (\b -> step b 1) l
-- Displays all objects in l beneath each other.
displayAll :: [Base] -> IO ()
displayAll l = putStrLn $ concat (intersperse "\n" $ map display l)
main =
let
-- Fill a list with "derived instances".
l :: [Base]
l = [Foo 0, Bar ""]
-- Step every object two times.
l' = (stepAll . stepAll) l
in
-- Show result.
displayAll l'
In D with OOP:
import std.stdio, std.conv, std.algorithm;
interface Base {
void step(in int delta) pure;
string display() const pure;
}
class Foo: Base {
this(in int i) pure nothrow { this.intVal = i; }
/// Add delta to internal state.
override void step(in int delta) pure nothrow { intVal += delta; }
override string display() const pure { return intVal.text; }
private int intVal;
}
class Bar: Base {
this(in string s) pure nothrow { this.strVal = s; }
/// Concat delta as string to internal state.
override void step(in int delta) pure { strVal ~= delta.text; }
override string display() const pure nothrow { return strVal; }
private string strVal;
}
alias BaseArr = Base[];
/// Steps every object in items by 1.
void stepAll(BaseArr items) pure {
foreach (o; items)
o.step(1);
}
/// Displays all objects in items beneath each other.
void displayAll(in BaseArr items) {
writefln("%-(%s\n%)", items.map!(o => o.display));
}
void main() {
// Fill a vector with base class pointers to derived instances.
//BaseArr l = [new Foo(0), new Bar("")];
BaseArr l = [new Foo(0)];
l ~= new Bar("");
// Step every object two times.
l.stepAll;
l.stepAll;
// Show result.
l.displayAll;
}
In D immutable:
import std.stdio, std.algorithm, std.variant, std.conv, std.array;
alias Base = Algebraic!(int, string);
Base step(in Base b, in int delta) {
if (auto bi = b.peek!int)
return Base(*bi + delta); // Add delta to internal state.
else if (auto bs = b.peek!string)
return Base(*bs ~ delta.text); // Concat delta as string to internal state.
assert(0);
}
string display(in Base b) {
if (auto bi = b.peek!int)
return text(*bi);
else if (auto bs = b.peek!string)
return *bs;
assert(0);
}
// Steps every object in l by 1.
Base[] stepAll(in Base[] l) { return l.map!(b => b.step(1)).array; }
// Displays all objects in l beneath each other.
void displayAll(in Base[] l) { writefln("%-(%s\n%)", l.map!display); }
void main() {
// Fill a list with "derived instances".
immutable l = [Base(0), Base("")];
// Step every object two times.
const l2 = l.stepAll.stepAll;
// Show result.
l2.displayAll;
}
How it could become with some improvements in Algebraic (it defines an enum of the types, usable in a final switch):
import std.stdio, std.algorithm, std.variant, std.conv, std.array;
alias Base = Algebraic!(int, string);
Base step(in Base b, in int delta) {
final switch (b.type) with (b) {
case intType: return Base(b.get!int + delta);
case stringType: return Base(b.get!string ~ delta.text);
}
}
string display(in Base b) {
final switch (b.type) with (b) {
case intType: return b.get!int.text;
case stringType: return b.get!string;
}
}
// Steps every object in l by 1.
Base[] stepAll(in Base[] l) { return l.map!(b => b.step(1)).array; }
// Displays all objects in l beneath each other.
void displayAll(in Base[] l) { writefln("%-(%s\n%)", l.map!display); }
void main() {
// Fill a list with "derived instances".
immutable l = [Base(0), Base("")];
// Step every object two times.
const l2 = l.stepAll.stepAll;
// Show result.
l2.displayAll;
}
This is much worse than the code you can write in Rust, but perhaps it's still usable.
Bye,
bearophile
|
