discriminated-union

Does F# support pattern matching of a discriminated union member instance by criteria other than the Identifier pattern ? For example, imagine that I want to match on the underlying shape of the data and I want to consider anything with an int * int shape, regardless of how the DU classifies the value. Is Here's how I'd do it now: type ExampleDU = | BinaryCase1 of x:int * y:int | BinaryCase2 of x:int * y:int | UnaryCase1 of x:int let underlyingValue = (1,2) let asCase1 = BinaryCase1 underlyingValue let asCase2 = BinaryCase2 underlyingValue let shapeName = match asCase1 with | BinaryCase1 (x,y)

Does Kotlin have anything like discriminated unions (sum types)? What would be the idiomatic Kotlin translation of this (F#): type OrderMessage = | New of Id: int * Quantity: int | Cancel of Id: int let handleMessage msg = match msg with | New(id, qty) -> handleNew id qty | Cancel(id) -> handleCxl id The common way of implementing this kind of abstraction in an OO-language (e.g. Kotlin or Scala) would be to through inheritance: open class OrderMessage private () { // private constructor to prevent creating more subclasses outside class New(val id: Int, val quantity: Int) : OrderMessage() class

I am trying to get the basics of F# clear before moving on to complex examples. The material I'm learning has introduced both Discriminate Unions and Record types. I have reviewed the material for both, but it is still unclear to me why we would use one over the other. Most of the toy examples I have created seem to be implementable in both. Records seem to be very close to what I think of as an object in C#, but I am trying to avoid relying on mapping to c# as a way to understand F# So... Are there clear reason to use one over the other? Are there certain canonical cases where one applies?

Code example: http://www.tryfsharp.org/create/dutts/Generics.fsx I have some mapping code in my F# which takes a C# object and wraps it in a discriminated union. module MyModule = type MappedThings = | DoThings of External.Things.DoThings type MappedStuff = | DoStuff of External.Stuff.DoStuff As I always use the same name in my discriminated union as the external object I would like to try to make my mapping code generic for scalability. This is what I've tried so far: let toDomain<'T> external : 'T = let found = FSharpType.GetUnionCases(typeof<'T>) |> Seq.where (fun t -> t.Name = external

I am writing a F# program which parses a string into a AST type which is a discriminated union. When I use fsi (on Mono + Mac OS X) to run my code, the AST is printed out in a nice format. But when I use printfn "%s" <| ast.ToString() I get something like FSI_0002.Absyn+clazz . Writing a ToString method for all the discriminated union types would be a big chore. How do I make the value print the way fsi does it? Have you tried printfn "%A" ast ? The %A specifier takes into consideration the StructuredFormatDisplayAttribute [MSDN] , if present. Kwang Yul Seo To convert a discriminated union

I have a class method which accepts a single argument as a string and returns an object which has the matching type property. This method is used to narrow a discriminated union type down, and guarantees that the returned object will always be of the particular narrowed type which has the provided type discriminate value. I'm trying to provide a type signature for this method that will correctly narrow the type down from a generic param, but nothing I try narrows it down from the discriminated union without the user explicitly providing the type it should be narrowed down to. That works, but